@0xsarwagya/ontoly-core 0.1.0-alpha.13 → 0.1.0-alpha.14

package/README.md

@@ -12,7 +12,7 @@ pnpm add @0xsarwagya/ontoly-core
 
 ## Status
 
-Alpha package for Ontoly v0.1.0-alpha.13. The public API is versioned with the Software Graph and RFC process.
+Alpha package for Ontoly v0.1.0-alpha.14. The public API is versioned with the Software Graph and RFC process.
 
 ## Links
 

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/semantic-index.ts
-var SEMANTIC_INDEX_VERSION = "1.0.0";
+var SEMANTIC_INDEX_VERSION = "1.0.1";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -63,7 +63,7 @@ var FRAMEWORK_SUFFIXES = /* @__PURE__ */ new Set([
 var CATEGORY_TYPES = {
   concept: [],
   symbol: ["Function", "Method", "Class", "Interface", "TypeAlias", "Enum", "Field", "Service", "Provider", "Controller", "Repository", "Resource", "Model", "Route"],
-  feature: ["Route", "Controller", "Service", "Provider", "Module", "Package", "Repository", "Model", "Resource", "Class", "Interface", "TypeAlias", "Function", "Method", "Operation"],
+  feature: ["Route", "Controller", "Service", "Provider", "Module", "Package", "Repository", "Model", "Resource", "Class", "Interface", "TypeAlias", "Function", "Method", "Operation", "Configuration", "EnvironmentVariable", "Guard", "Permission", "Middleware"],
   configuration: ["Configuration", "EnvironmentVariable", "BuildTarget", "Script", "Task"],
   environment: ["EnvironmentVariable"],
   route: ["Route", "Operation", "Controller"],
@@ -133,8 +133,67 @@ var SEMANTIC_EXPANSIONS = {
 var SEMANTIC_METADATA_DEPTH_LIMIT = 3;
 var SEMANTIC_METADATA_ARRAY_LIMIT = 12;
 var SEMANTIC_METADATA_ENTRY_LIMIT = 24;
-var SEMANTIC_METADATA_VALUES_LIMIT = 80;
+var SEMANTIC_METADATA_VALUES_LIMIT = 48;
 var SEMANTIC_TEXT_LIMIT = 240;
+var SEMANTIC_ALIAS_SOURCE_LIMIT = 16;
+var SEMANTIC_ALIAS_LIMIT = 20;
+var SEMANTIC_KEYWORD_LIMIT = 24;
+var SEMANTIC_INVERTED_IDS_LIMIT = 160;
+var SEMANTIC_VOCABULARY_IDS_LIMIT = 50;
+var SEMANTIC_NOISE_TERMS = /* @__PURE__ */ new Set([
+  "0",
+  "0s",
+  "1",
+  "1s",
+  "2",
+  "2s",
+  "3",
+  "3s",
+  "4",
+  "4s",
+  "abstract",
+  "abstracts",
+  "active",
+  "actives",
+  "anies",
+  "any",
+  "async",
+  "asyncs",
+  "boolean",
+  "booleans",
+  "false",
+  "falses",
+  "number",
+  "numbers",
+  "parameter",
+  "parameters",
+  "static",
+  "statics",
+  "string",
+  "strings",
+  "true",
+  "trues",
+  "typeparameter",
+  "typeparameters"
+]);
+var REPOSITORY_LOCAL_KIND_BOOSTS = {
+  Service: 112,
+  Controller: 92,
+  Repository: 72,
+  Route: 68,
+  Operation: 64,
+  Method: 62,
+  Module: 58,
+  Configuration: 58,
+  Model: 56,
+  Interface: 54,
+  TypeAlias: 54,
+  Class: 50,
+  Function: 48,
+  EnvironmentVariable: 44,
+  Provider: 42
+};
+var FRAMEWORK_PACKAGE_PATTERN = /@nestjs\/|@medplum\/|next\/dist|react\/|typescript\/lib|@types\/|@babel\/|@typescript-eslint\/|tslib|rxjs|zone\.js/i;
 function createSemanticIndex(graph) {
   const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
   const incoming = groupEdges(graph.edges, "to");
@@ -352,12 +411,12 @@ function aliasSourceValues(graph, node, neighbors, parentChain) {
     node.file ?? "",
     node.package ?? "",
     ...parentChain,
-    ...metadataValues,
     ...routeValues,
     ...envValues,
-    ...neighbors.map((neighbor) => neighbor.name),
-    ...neighbors.map((neighbor) => neighbor.id)
-  ].filter(Boolean));
+    ...neighbors.slice(0, 16).map((neighbor) => neighbor.name),
+    ...neighbors.slice(0, 16).map((neighbor) => neighbor.id),
+    ...metadataValues
+  ].filter(Boolean)).slice(0, SEMANTIC_ALIAS_SOURCE_LIMIT);
 }
 function generateAliases(values, node) {
   const aliases = /* @__PURE__ */ new Set();
@@ -379,6 +438,9 @@ function generateAliases(values, node) {
         aliases.add(withoutSuffix.join(""));
       }
       for (const token of tokens) {
+        if (isSemanticNoiseTerm(token)) {
+          continue;
+        }
         aliases.add(token);
         aliases.add(singularize(token));
         aliases.add(pluralize(token));
@@ -408,12 +470,15 @@ function generateAliases(values, node) {
     aliases.add("feature");
     aliases.add("feature module");
   }
-  return uniqueStrings([...aliases].filter((alias) => alias.length > 1));
+  return uniqueStrings([...aliases].filter((alias) => alias.length > 1).filter((alias) => !isNoisySemanticAlias(alias))).slice(0, SEMANTIC_ALIAS_LIMIT);
 }
 function generateKeywords(values, node) {
   const keywords = /* @__PURE__ */ new Set();
   for (const value of values) {
     for (const token of tokenize(value)) {
+      if (isSemanticNoiseTerm(token)) {
+        continue;
+      }
       keywords.add(token);
       keywords.add(singularize(token));
     }
@@ -434,7 +499,7 @@ function generateKeywords(values, node) {
   if (isFeatureModuleNode(node)) {
     keywords.add("feature");
   }
-  return uniqueStrings([...keywords].filter((keyword) => keyword.length > 1));
+  return uniqueStrings([...keywords].filter((keyword) => keyword.length > 1).filter((keyword) => !isSemanticNoiseTerm(keyword))).slice(0, SEMANTIC_KEYWORD_LIMIT);
 }
 function buildInvertedIndex(entries) {
   const inverted = /* @__PURE__ */ new Map();
@@ -457,9 +522,14 @@ function buildVocabulary(entries) {
       if (term.length < 2 || STOP_WORDS.has(term)) {
         continue;
       }
+      if (isSemanticNoiseTerm(term)) {
+        continue;
+      }
       const current = terms.get(term) ?? { count: 0, nodeIds: /* @__PURE__ */ new Set(), kinds: /* @__PURE__ */ new Set() };
       current.count += 1;
-      current.nodeIds.add(entry.stableId);
+      if (current.nodeIds.size < SEMANTIC_VOCABULARY_IDS_LIMIT) {
+        current.nodeIds.add(entry.stableId);
+      }
       current.kinds.add(entry.kind);
       terms.set(term, current);
     }
@@ -476,7 +546,7 @@ function rankCandidates(index, intent, options) {
   const entryById = new Map(index.entries.map((entry) => [entry.stableId, entry]));
   const kinds = options.kinds?.length ? new Set(options.kinds) : categoryTypeSet(options.category);
   const candidates = candidateIds.map((id) => entryById.get(id)).filter(isEntry).filter((entry) => includeEntryForCategory(entry, intent, options.category)).filter((entry) => !kinds || kinds.has(entry.kind)).filter((entry) => !options.packageScope || entry.package === options.packageScope || entry.filePath?.startsWith(options.packageScope)).map((entry) => scoreEntry(entry, intent, options.category)).filter((candidate) => candidate.score > 0).sort(compareCandidates);
-  return candidates.slice(0, options.limit ?? 20);
+  return calibrateCandidateConfidences(candidates, intent, options.category).slice(0, options.limit ?? 20);
 }
 function candidateIdsFor(index, intent) {
   const ids = /* @__PURE__ */ new Set();
@@ -486,14 +556,59 @@ function candidateIdsFor(index, intent) {
       ids.add(id);
     }
   }
+  for (const id of repositoryVocabularyCandidateIds(index, terms)) {
+    ids.add(id);
+  }
   const fuzzyIds = index.entries.filter((entry) => fuzzyEntryMatch(entry, intent)).map((entry) => entry.stableId).sort();
   if (ids.size > 0) {
     for (const id of fuzzyIds.slice(0, 250)) {
       ids.add(id);
     }
-    return [...ids].sort();
+    return [...expandCandidateIds(index, intent, [...ids])].sort();
   }
-  return fuzzyIds;
+  return [...expandCandidateIds(index, intent, fuzzyIds)].sort();
+}
+function repositoryVocabularyCandidateIds(index, terms) {
+  const termSet = new Set(terms);
+  const ids = /* @__PURE__ */ new Set();
+  for (const vocabularyTerm of index.vocabulary) {
+    if (termSet.has(vocabularyTerm.term)) {
+      for (const id of vocabularyTerm.nodeIds) {
+        ids.add(id);
+      }
+    }
+  }
+  for (const vocabularyTerm of index.vocabulary) {
+    if (ids.size >= 300) {
+      break;
+    }
+    if (!termSet.has(vocabularyTerm.term) && vocabularyTerm.term.length > 3 && terms.some((term) => term.length > 3 && (term.includes(vocabularyTerm.term) || vocabularyTerm.term.includes(term)))) {
+      for (const id of vocabularyTerm.nodeIds.slice(0, 20)) {
+        ids.add(id);
+      }
+    }
+  }
+  return [...ids].sort();
+}
+function expandCandidateIds(index, intent, seedIds) {
+  const ids = new Set(seedIds);
+  const entryById = new Map(index.entries.map((entry) => [entry.stableId, entry]));
+  for (const id of seedIds.slice(0, 300)) {
+    const entry = entryById.get(id);
+    if (!entry || semanticFeatureAgreement(entry, intent) < 0.35) {
+      continue;
+    }
+    for (const neighborId of entry.relationships.neighborIds) {
+      const neighbor = entryById.get(neighborId);
+      if (!neighbor) {
+        continue;
+      }
+      if (semanticFeatureAgreement(neighbor, intent) >= 0.25 || architectureAgreementConfidence(neighbor, "feature") >= 0.75) {
+        ids.add(neighborId);
+      }
+    }
+  }
+  return [...ids];
 }
 function scoreEntry(entry, intent, category) {
   const reasons = [];
@@ -540,94 +655,347 @@ function scoreEntry(entry, intent, category) {
   addScore(reasons, "intent-expansion", expandedMatches.length * 32, expandedMatches.join(", "));
   const relationshipMatches = intent.expandedTerms.filter((term) => entry.relationships.neighborNames.some((name) => tokenize(name).includes(term)));
   addScore(reasons, "relationship-context", Math.min(120, relationshipMatches.length * 18), relationshipMatches.join(", "));
+  const semanticSimilarity = semanticSimilarityConfidence(entry, intent);
+  addScore(reasons, "semantic-similarity", semanticSimilarity * 140, `${Math.round(semanticSimilarity * 100)}% lexical/semantic coverage`);
+  const featureAgreement = semanticFeatureAgreement(entry, intent);
+  addScore(reasons, "feature-agreement", featureAgreement * 120, `${Math.round(featureAgreement * 100)}% repository feature agreement`);
+  const queryCoverage = originalQueryCoverage(entry, intent);
+  addScore(reasons, "query-token-coverage", queryCoverage.ratio * 110, `${Math.round(queryCoverage.ratio * 100)}% original query token coverage`);
+  const architectureAgreement = architectureAgreementConfidence(entry, category);
+  addScore(reasons, "architecture-agreement", architectureAgreement * 90, `${entry.kind} agreement for ${category}`);
   const categoryBoost = categoryBoostFor(entry, category);
   addScore(reasons, "architecture-layer", categoryBoost, `${entry.kind} in ${entry.architectureLayer}`);
+  addScore(reasons, "feature-owner", featureOwnerBoostFor(entry, category), `${entry.displayName} owns repository feature behavior`);
   addScore(reasons, "graph-importance", Math.min(90, entry.importance * 18), `degree ${entry.relationships.degree}`);
   addScore(reasons, "usage-frequency", Math.min(60, entry.usageFrequency * 8), `${entry.usageFrequency} incoming edges`);
   addScore(reasons, "repository-locality", repositoryLocalityBoost(entry), repositoryLocalityEvidence(entry));
-  const penalty = repositoryRankingPenalty(entry);
+  const penalty = repositoryRankingPenalty(entry) + queryCoverage.missing.length * 120 + semanticFeaturePenalty(entry, intent);
   const score = Math.max(0, reasons.reduce((total, reason) => total + reason.score, 0) - penalty);
-  const returnedReasons = penalty > 0 ? [...reasons, { factor: "repository-noise-demotion", score: -penalty, evidence: repositoryNoiseEvidence(entry) }] : reasons;
+  const returnedReasons = penalty > 0 ? [...reasons, { factor: "repository-noise-demotion", score: -penalty, evidence: repositoryNoiseEvidence(entry, queryCoverage.missing) }] : reasons;
   return {
     nodeId: entry.stableId,
     stableId: entry.stableId,
     displayName: entry.displayName,
     kind: entry.kind,
     score: round(score, 3),
-    confidence: round(Math.min(1, score / 650), 3),
+    confidence: round(confidenceFromCandidateSignals(entry, intent, category, score), 3),
     matchedTerms: uniqueStrings([...matchedTerms]),
     reasons: returnedReasons.filter((reason) => reason.score !== 0).sort(compareReasons),
     entry
   };
 }
-function repositoryLocalityBoost(entry) {
-  let score = 0;
-  if (isRepositoryLocalEntry(entry)) {
-    score += 32;
+function calibrateCandidateConfidences(candidates, intent, category) {
+  if (candidates.length === 0) {
+    return candidates;
   }
-  if (["Service", "Controller", "Repository", "Provider"].includes(entry.kind)) {
-    score += 34;
+  const topScore = candidates[0]?.score ?? 0;
+  const secondScore = candidates[1]?.score ?? 0;
+  const closeAlternatives = candidates.filter(
+    (candidate, index) => index > 0 && isPlausibleAlternative(candidate, topScore, secondScore)
+  );
+  return candidates.map((candidate, index) => {
+    const baseConfidence = confidenceFromCandidateSignals(candidate.entry, intent, category, candidate.score);
+    const ratio = topScore > 0 ? Math.min(1, candidate.score / topScore) : 0;
+    const confidence = round(calibratedConfidenceCap(candidate, baseConfidence * (index === 0 ? 1 : ratio), {
+      index,
+      topScore,
+      secondScore,
+      closeAlternatives,
+      intent,
+      category
+    }), 3);
+    const reasons = [
+      ...candidate.reasons,
+      {
+        factor: "confidence-calibration",
+        score: round(confidence * 100),
+        evidence: confidenceCalibrationEvidence(candidate.entry, confidence, closeAlternatives.length)
+      }
+    ];
+    if (index === 0 && closeAlternatives.length > 0) {
+      reasons.push({
+        factor: "ambiguity-calibration",
+        score: -Math.min(30, closeAlternatives.length * 8),
+        evidence: `${closeAlternatives.length} plausible alternative seed(s) were retained.`
+      });
+    }
+    return {
+      ...candidate,
+      confidence,
+      reasons: reasons.filter((reason) => reason.score !== 0).sort(compareReasons)
+    };
+  });
+}
+function calibratedConfidenceCap(candidate, confidence, context) {
+  let capped = Math.max(0, Math.min(1, confidence));
+  const isExact = candidate.reasons.some((reason) => reason.factor === "exact-symbol" || reason.factor === "exact-normalized-name");
+  const scoreGap = context.topScore - context.secondScore;
+  if (isExternalOrFrameworkEntry(candidate.entry)) {
+    capped = Math.min(capped, hasRepositoryLocalAlternative(context.closeAlternatives) ? 0.52 : 0.58);
   }
-  if (["Module", "Route", "Operation"].includes(entry.kind)) {
-    score += 26;
+  if (isGenericUtilityEntry(candidate.entry) && !isExact) {
+    capped = Math.min(capped, 0.72);
   }
-  if (isRepositorySymbolEntry(entry)) {
-    score += 16;
+  if (context.closeAlternatives.length > 0 && !isExact) {
+    capped = Math.min(capped, Math.max(0.72, 0.9 - context.closeAlternatives.length * 0.06));
   }
-  if (isDtoLikeEntry(entry)) {
-    score += 28;
+  if (context.index === 0 && scoreGap > 0 && scoreGap < 45 && !isExact) {
+    capped = Math.min(capped, 0.78);
+  } else if (context.index === 0 && scoreGap > 0 && scoreGap < 90 && !isExact) {
+    capped = Math.min(capped, 0.86);
   }
-  if (isFeatureModuleEntry(entry)) {
-    score += 8;
+  if (context.intent.tokens.length >= 2 && originalTokenCoverage(candidate.entry, context.intent) < 0.5 && !isExact) {
+    capped = Math.min(capped, 0.62);
+  }
+  if (context.index > 0) {
+    capped = Math.min(capped, 0.84);
+  }
+  if (context.category === "feature" && architectureAgreementConfidence(candidate.entry, context.category) < 0.4 && !isExact) {
+    capped = Math.min(capped, 0.6);
+  }
+  return capped;
+}
+function isPlausibleAlternative(candidate, topScore, secondScore) {
+  return candidate.score >= Math.max(secondScore, topScore - 90) || candidate.score >= topScore * 0.84;
+}
+function hasRepositoryLocalAlternative(candidates) {
+  return candidates.some((candidate) => isRepositoryLocalEntry(candidate.entry));
+}
+function confidenceCalibrationEvidence(entry, confidence, alternativeCount) {
+  const locality = isRepositoryLocalEntry(entry) ? "repository-local" : "external/framework";
+  const ambiguity = alternativeCount > 0 ? ` with ${alternativeCount} plausible alternative(s)` : "";
+  return `${locality} ${entry.kind} calibrated to ${confidence.toFixed(3)}${ambiguity}`;
+}
+function confidenceFromCandidateSignals(entry, intent, category, score) {
+  const semantic = semanticSimilarityConfidence(entry, intent);
+  const locality = repositoryLocalityConfidence(entry);
+  const architecture = architectureAgreementConfidence(entry, category);
+  const feature = semanticFeatureAgreement(entry, intent);
+  const connectivity = graphConnectivityConfidence(entry);
+  const scoreConfidence = Math.min(1, score / 760);
+  const confidence = semantic * 0.32 + locality * 0.22 + architecture * 0.16 + feature * 0.16 + connectivity * 0.08 + scoreConfidence * 0.06;
+  const exact = entry.normalizedName === intent.normalized || normalizePhrase(entry.stableId) === intent.normalized || entry.aliases.includes(intent.normalized);
+  return exact ? Math.max(confidence, isRepositoryLocalEntry(entry) ? 0.78 : 0.55) : confidence;
+}
+function semanticSimilarityConfidence(entry, intent) {
+  const entryTerms = /* @__PURE__ */ new Set([entry.normalizedName, ...entry.aliases, ...entry.keywords]);
+  if (!intent.normalized) {
+    return 0;
   }
-  if (["Configuration", "EnvironmentVariable"].includes(entry.kind)) {
-    score += 18;
+  if (entry.normalizedName === intent.normalized || entry.aliases.includes(intent.normalized) || normalizePhrase(entry.stableId) === intent.normalized) {
+    return 1;
+  }
+  const originalCoverage = originalTokenCoverage(entry, intent);
+  const expandedTerms = intent.expandedTerms.filter((term) => !intent.tokens.includes(term));
+  const expandedCoverage = expandedTerms.length === 0 ? 0 : expandedTerms.filter((term) => entryTerms.has(term)).length / expandedTerms.length;
+  const phraseCoverage = intent.phrases.some((phrase) => entryTerms.has(phrase)) ? 0.9 : intent.phrases.some((phrase) => [...entryTerms].some((term) => term.includes(phrase) || phrase.includes(term))) ? 0.55 : 0;
+  return Math.min(1, Math.max(phraseCoverage, originalCoverage * 0.78 + expandedCoverage * 0.22));
+}
+function originalTokenCoverage(entry, intent) {
+  if (intent.tokens.length === 0) {
+    return 0;
+  }
+  const entryTerms = /* @__PURE__ */ new Set([entry.normalizedName, ...entry.aliases, ...entry.keywords]);
+  const searchableText = [
+    entry.stableId,
+    entry.displayName,
+    entry.filePath ?? "",
+    entry.folderPath ?? "",
+    entry.parentChain.join(" "),
+    entry.relationships.neighborNames.join(" "),
+    entry.documentation ?? "",
+    entry.comments ?? ""
+  ].join(" ").toLowerCase();
+  const matches = intent.tokens.filter(
+    (token) => entryTerms.has(token) || entryTerms.has(singularize(token)) || searchableText.includes(token)
+  );
+  return matches.length / intent.tokens.length;
+}
+function originalQueryCoverage(entry, intent) {
+  const required = uniqueStrings(intent.tokens.map((token) => singularize(token)).filter((token) => token.length > 2));
+  if (required.length === 0) {
+    return { matched: [], missing: [], ratio: 1 };
+  }
+  const entryTerms = new Set([entry.normalizedName, ...entry.aliases, ...entry.keywords].flatMap((term) => tokenize(term).map(singularize)));
+  const searchableTerms = new Set(tokenize([
+    entry.stableId,
+    entry.displayName,
+    entry.filePath ?? "",
+    entry.folderPath ?? "",
+    entry.parentChain.join(" "),
+    entry.relationships.neighborNames.join(" "),
+    entry.documentation ?? "",
+    entry.comments ?? ""
+  ].join(" ")).map(singularize));
+  const matched = required.filter((term) => entryTerms.has(term) || searchableTerms.has(term));
+  const missing = required.filter((term) => !matched.includes(term));
+  return { matched, missing, ratio: matched.length / required.length };
+}
+function semanticFeatureAgreement(entry, intent) {
+  if (intent.tokens.length === 0) {
+    return 0;
   }
-  if (/(^|[/.])(test|tests|spec|__tests__)([/.]|$)|\.(test|spec)\./i.test(entry.filePath ?? "")) {
+  const featureText = tokenize([
+    entry.stableId,
+    entry.displayName,
+    entry.filePath ?? "",
+    entry.folderPath ?? "",
+    entry.parentChain.join(" "),
+    entry.relationships.neighborNames.join(" "),
+    entry.documentation ?? "",
+    entry.comments ?? ""
+  ].join(" "));
+  const featureTerms = new Set(featureText);
+  const original = intent.tokens.filter((token) => featureTerms.has(token) || featureTerms.has(singularize(token))).length / intent.tokens.length;
+  const expanded = intent.expandedTerms.length === 0 ? 0 : intent.expandedTerms.filter((term) => featureTerms.has(term)).length / intent.expandedTerms.length;
+  return Math.min(1, original * 0.82 + expanded * 0.18);
+}
+function semanticFeaturePenalty(entry, intent) {
+  const required = new Set(intent.tokens.map(singularize));
+  const terms = new Set(tokenize([
+    entry.stableId,
+    entry.displayName,
+    entry.filePath ?? "",
+    entry.folderPath ?? "",
+    entry.parentChain.join(" "),
+    entry.relationships.neighborNames.join(" "),
+    entry.documentation ?? "",
+    entry.comments ?? ""
+  ].join(" ")).map(singularize));
+  let penalty = 0;
+  if (required.has("threshold") && !terms.has("threshold")) {
+    penalty += 130;
+  }
+  if (required.has("threshold") && (terms.has("statistic") || terms.has("observation")) && !terms.has("threshold")) {
+    penalty += 220;
+  }
+  if (required.has("duration") && required.has("sleep") && !terms.has("duration")) {
+    penalty += 80;
+  }
+  return penalty;
+}
+function repositoryLocalityConfidence(entry) {
+  if (!isRepositoryLocalEntry(entry)) {
+    return 0.08;
+  }
+  if (isGenericUtilityEntry(entry)) {
+    return 0.72;
+  }
+  if (!entry.filePath && (entry.kind === "Dependency" || entry.kind === "Framework")) {
+    return 0.2;
+  }
+  return 1;
+}
+function architectureAgreementConfidence(entry, category) {
+  if (isExternalOrFrameworkEntry(entry)) {
+    return 0.12;
+  }
+  if (isPreferredRepositorySeedEntry(entry)) {
+    return 1;
+  }
+  if (categoryTypeSet(category)?.has(entry.kind)) {
+    return 0.82;
+  }
+  if (entry.architectureLayer === "architecture" && category === "feature") {
+    return 0.4;
+  }
+  return entry.architectureLayer === "language" ? 0.55 : 0.65;
+}
+function graphConnectivityConfidence(entry) {
+  return Math.min(1, 0.25 + Math.log2(entry.relationships.degree + 1) / 4);
+}
+function repositoryLocalityBoost(entry) {
+  let score = 0;
+  if (isRepositoryLocalEntry(entry)) {
+    score += 56;
+    score += REPOSITORY_LOCAL_KIND_BOOSTS[entry.kind] ?? 0;
+  }
+  if (isDtoLikeEntry(entry)) {
+    score += 46;
+  }
+  if (isMapperEntry(entry)) {
+    score += 34;
+  }
+  if (isFeatureModuleEntry(entry)) {
     score += 22;
   }
+  if (isTestEntry(entry)) {
+    score += 28;
+  }
   return score;
 }
 function repositoryRankingPenalty(entry) {
   let penalty = 0;
   const text = `${entry.stableId} ${entry.filePath ?? ""} ${entry.package ?? ""} ${entry.displayName}`.toLowerCase();
   if (text.includes("node_modules") || entry.stableId.startsWith("dep:")) {
-    penalty += 120;
+    penalty += 260;
   }
   if (/(\bdto\b|dto$|schema$|type$|types$|generated|__generated__)/i.test(entry.displayName) && !isRepositoryLocalEntry(entry)) {
-    penalty += 35;
+    penalty += 90;
   }
-  if (/node_modules|@nestjs\/|next\/dist|react\/|typescript\/lib/i.test(text)) {
-    penalty += 80;
+  if (/node_modules|@nestjs\/|@medplum\/|next\/dist|react\/|typescript\/lib|@types\//i.test(text)) {
+    penalty += 180;
+  }
+  if (isExternalOrFrameworkEntry(entry)) {
+    penalty += 120;
   }
   if (/^framework:|framework|adapter|platform|runtime/.test(entry.stableId.toLowerCase()) && !isRepositoryLocalEntry(entry)) {
-    penalty += 55;
+    penalty += 90;
   }
   if (isGenericUtilityEntry(entry)) {
-    penalty += 35;
+    penalty += 55;
   }
   return penalty;
 }
 function repositoryLocalityEvidence(entry) {
   return isRepositoryLocalEntry(entry) ? `${entry.kind} from repository-local graph evidence` : `${entry.kind} from external or generated boundary`;
 }
-function repositoryNoiseEvidence(entry) {
-  return `${entry.displayName} is external, generated, or generic framework-adjacent evidence`;
+function repositoryNoiseEvidence(entry, missingTerms = []) {
+  const missing = missingTerms.length > 0 ? `; missing query term(s): ${missingTerms.join(", ")}` : "";
+  return `${entry.displayName} is external, generated, generic framework-adjacent, or lower-coverage evidence${missing}`;
 }
 function isRepositoryLocalEntry(entry) {
   const text = `${entry.stableId} ${entry.filePath ?? ""} ${entry.package ?? ""}`.toLowerCase();
-  return !text.includes("node_modules") && !entry.stableId.startsWith("dep:") && !entry.stableId.startsWith("framework:");
-}
-function isRepositorySymbolEntry(entry) {
-  return ["Function", "Method", "Class", "Interface", "TypeAlias", "Enum", "Field", "Model", "Resource"].includes(entry.kind);
+  return !text.includes("node_modules") && !entry.stableId.startsWith("dep:") && !entry.stableId.startsWith("framework:") && !isKnownExternalPackageEntry(entry);
 }
 function isDtoLikeEntry(entry) {
   const text = `${entry.displayName} ${entry.filePath ?? ""} ${entry.keywords.join(" ")}`;
   return ["Model", "Interface", "TypeAlias", "Class"].includes(entry.kind) && /\bdto\b|dto$|data transfer|payload|request|response/i.test(text);
 }
+function featureOwnerBoostFor(entry, category) {
+  if (category !== "feature" && category !== "concept" || !isRepositoryLocalEntry(entry)) {
+    return 0;
+  }
+  if (entry.kind === "Service" || entry.kind === "Provider") {
+    return 170;
+  }
+  if (entry.kind === "Class" && /service$/i.test(entry.displayName)) {
+    return 170;
+  }
+  if (entry.kind === "Controller") {
+    return 90;
+  }
+  return 0;
+}
 function isFeatureModuleEntry(entry) {
   return entry.kind === "Module" && isRepositoryLocalEntry(entry) && !isGenericUtilityEntry(entry);
 }
+function isPreferredRepositorySeedEntry(entry) {
+  return isRepositoryLocalEntry(entry) && (["Service", "Controller", "Repository", "Method", "Route", "Operation", "Configuration", "EnvironmentVariable", "Guard", "Permission", "Middleware"].includes(entry.kind) || isDtoLikeEntry(entry) || isFeatureModuleEntry(entry) || isTestEntry(entry) || isMapperEntry(entry));
+}
+function isMapperEntry(entry) {
+  return isRepositoryLocalEntry(entry) && /\bmapper\b|mapper$/i.test(`${entry.displayName} ${entry.filePath ?? ""}`);
+}
+function isTestEntry(entry) {
+  return /(^|[/.])(test|tests|spec|__tests__)([/.]|$)|\.(test|spec)\./i.test(`${entry.filePath ?? ""} ${entry.displayName}`);
+}
+function isExternalOrFrameworkEntry(entry) {
+  return !isRepositoryLocalEntry(entry) || entry.kind === "Dependency" || entry.kind === "Framework" || isKnownExternalPackageEntry(entry);
+}
+function isKnownExternalPackageEntry(entry) {
+  const text = `${entry.stableId} ${entry.displayName} ${entry.package ?? ""} ${entry.filePath ?? ""}`.toLowerCase();
+  return FRAMEWORK_PACKAGE_PATTERN.test(text) || /(^|[/:])(@nestjs|@medplum|@types|@angular|next|react|typescript|express|fastify)([/:-]|$)/.test(text) || /(^|[/:])(node|npm):/.test(text);
+}
 function isGenericUtilityEntry(entry) {
   const text = `${entry.stableId} ${entry.displayName} ${entry.filePath ?? ""}`.toLowerCase();
   return /(^|[/.:-])(common|shared|utils?|helpers?|internal|misc|core|index)([/.:-]|$)/.test(text) || /\b(base|abstract|generic|utility|utils?|helpers?)\b/.test(entry.displayName);
@@ -900,7 +1268,20 @@ function collectMetadataText(value, values, depth, seen) {
   }
 }
 function isNoisyMetadataKey(key) {
-  return ["language", "parser", "parserVersion", "passId", "provenance", "source"].includes(key);
+  return [
+    "abstract",
+    "async",
+    "declarationKind",
+    "language",
+    "parameters",
+    "parser",
+    "parserVersion",
+    "passId",
+    "provenance",
+    "source",
+    "static",
+    "typeParameters"
+  ].includes(key);
 }
 function routeTextValues(node) {
   if (node.type !== "Route" && node.type !== "Operation") {
@@ -962,10 +1343,13 @@ function groupEdges(edges, side) {
   return new Map([...grouped.entries()].map(([key, values]) => [key, values.sort(compareEdges)]));
 }
 function addInverted(map, term, id) {
-  if (!term || STOP_WORDS.has(term)) {
+  if (!term || STOP_WORDS.has(term) || isSemanticNoiseTerm(term) || isNoisySemanticAlias(term)) {
     return;
   }
   const current = map.get(term) ?? /* @__PURE__ */ new Set();
+  if (current.size >= SEMANTIC_INVERTED_IDS_LIMIT) {
+    return;
+  }
   current.add(id);
   map.set(term, current);
 }
@@ -990,6 +1374,19 @@ function compareEdges(left, right) {
 function uniqueStrings(values) {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
 }
+function isSemanticNoiseTerm(term) {
+  return SEMANTIC_NOISE_TERMS.has(term) || /^\d+[a-z]*$/i.test(term);
+}
+function isNoisySemanticAlias(alias) {
+  const tokens = tokenize(alias);
+  if (tokens.length === 0) {
+    return true;
+  }
+  if (tokens.length > 14) {
+    return true;
+  }
+  return tokens.every(isSemanticNoiseTerm);
+}
 function sum(values) {
   return values.reduce((total, value) => total + value, 0);
 }