@decantr/registry 2.0.0 → 2.2.0

package/dist/index.js

@@ -121,6 +121,8 @@ var RegistryAPIClient = class {
     if (params?.recommended) searchParams.set("recommended", "true");
     if (params?.intelligenceSource)
       searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params?.blueprintSet) searchParams.set("blueprint_set", params.blueprintSet);
+    if (params?.labs) searchParams.set("labs", "true");
     if (params?.limit) searchParams.set("limit", String(params.limit));
     if (params?.offset) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
@@ -180,6 +182,8 @@ var RegistryAPIClient = class {
     if (params.recommended) searchParams.set("recommended", "true");
     if (params.intelligenceSource)
       searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params.blueprintSet) searchParams.set("blueprint_set", params.blueprintSet);
+    if (params.labs) searchParams.set("labs", "true");
     if (params.limit) searchParams.set("limit", String(params.limit));
     if (params.offset) searchParams.set("offset", String(params.offset));
     return this.request(`/search?${searchParams}`);
@@ -203,6 +207,8 @@ var RegistryAPIClient = class {
     if (params?.recommended) searchParams.set("recommended", "true");
     if (params?.intelligenceSource)
       searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params?.blueprintSet) searchParams.set("blueprint_set", params.blueprintSet);
+    if (params?.labs) searchParams.set("labs", "true");
     if (params?.limit != null) searchParams.set("limit", String(params.limit));
     if (params?.offset != null) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
@@ -352,6 +358,257 @@ function createRegistryClient(options = {}) {
   };
 }
 
+// src/discovery.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "app",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "have",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "page",
+  "route",
+  "section",
+  "that",
+  "the",
+  "this",
+  "to",
+  "ui",
+  "with"
+]);
+var DOMAIN_LANGUAGE = {
+  recipe: [
+    "cookbook",
+    "cookbooks",
+    "cooking",
+    "dish",
+    "food",
+    "ingredient",
+    "ingredients",
+    "meal",
+    "photo",
+    "recipe",
+    "recipes"
+  ],
+  ai: [
+    "agent",
+    "ai",
+    "assistant",
+    "chat",
+    "claude",
+    "generate",
+    "generation",
+    "image",
+    "model",
+    "prompt",
+    "vision"
+  ],
+  social: [
+    "activity",
+    "avatar",
+    "comment",
+    "community",
+    "feed",
+    "follow",
+    "like",
+    "profile",
+    "share",
+    "social",
+    "user"
+  ],
+  commerce: ["cart", "checkout", "commerce", "ecommerce", "order", "price", "product", "shop"],
+  dashboard: ["analytics", "chart", "dashboard", "kpi", "metric", "report", "table"],
+  form: ["form", "input", "settings", "submit", "toggle", "upload"]
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function recordToText(value) {
+  if (!isRecord2(value)) return "";
+  return Object.values(value).flatMap((entry) => {
+    if (typeof entry === "string") return [entry];
+    if (Array.isArray(entry))
+      return entry.filter((item) => typeof item === "string");
+    if (isRecord2(entry)) return [recordToText(entry)];
+    return [];
+  }).join(" ");
+}
+function patternToDiscoveryCandidate(pattern, options = {}) {
+  const record = pattern;
+  const slug = options.slug || (typeof record.slug === "string" ? record.slug : void 0) || (typeof record.id === "string" ? record.id : void 0);
+  return {
+    id: typeof record.id === "string" ? record.id : slug ?? "pattern",
+    slug,
+    name: typeof record.name === "string" ? record.name : slug,
+    description: typeof record.description === "string" ? record.description : void 0,
+    tags: stringArray(record.tags),
+    components: stringArray(record.components),
+    interactions: stringArray(record.interactions),
+    visual_brief: typeof record.visual_brief === "string" ? record.visual_brief : typeof record.visualBrief === "string" ? record.visualBrief : void 0,
+    layout_hints: isRecord2(record.layout_hints) ? record.layout_hints : void 0,
+    aliases: stringArray(record.aliases),
+    category: typeof record.category === "string" ? record.category : void 0,
+    domain: typeof record.domain === "string" ? record.domain : void 0,
+    source: options.source,
+    pattern
+  };
+}
+function tokenize(value) {
+  if (!value) return [];
+  const tokens = value.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").split(/[^a-z0-9]+/g).map((token) => token.trim()).filter((token) => token.length >= 2 && !STOP_WORDS.has(token));
+  return [...new Set(tokens)];
+}
+function inferDomainTerms(tokens) {
+  const tokenSet = new Set(tokens);
+  const matches = [];
+  for (const [domain, terms] of Object.entries(DOMAIN_LANGUAGE)) {
+    const hits = terms.filter((term) => tokenSet.has(term));
+    if (hits.length > 0) matches.push({ domain, terms });
+  }
+  return matches;
+}
+function candidateText(candidate) {
+  const pattern = candidate.pattern;
+  const patternRecord = isRecord2(pattern) ? pattern : {};
+  const presets = isRecord2(patternRecord.presets) ? recordToText(patternRecord.presets) : "";
+  const composition = isRecord2(patternRecord.composition) ? recordToText(patternRecord.composition) : "";
+  const motion = isRecord2(patternRecord.motion) ? recordToText(patternRecord.motion) : "";
+  const responsive = isRecord2(patternRecord.responsive) ? recordToText(patternRecord.responsive) : "";
+  const accessibility = isRecord2(patternRecord.accessibility) ? recordToText(patternRecord.accessibility) : "";
+  return {
+    high: [
+      candidate.slug,
+      candidate.id,
+      candidate.name,
+      candidate.aliases?.join(" "),
+      candidate.category,
+      candidate.domain
+    ].filter(Boolean).join(" "),
+    medium: [
+      candidate.description,
+      candidate.tags?.join(" "),
+      candidate.components?.join(" "),
+      candidate.interactions?.join(" "),
+      candidate.visual_brief,
+      candidate.layout_hints ? recordToText(candidate.layout_hints) : ""
+    ].filter(Boolean).join(" "),
+    low: [presets, composition, motion, responsive, accessibility].filter(Boolean).join(" ")
+  };
+}
+function fieldMatches(tokens, text) {
+  const lower = text.toLowerCase();
+  return tokens.filter((token) => lower.includes(token));
+}
+function addReason(reasons, reason) {
+  if (!reasons.includes(reason)) reasons.push(reason);
+}
+function scorePatternCandidate(input, candidate) {
+  const queryTokens = tokenize(input.query);
+  const routeTokens = tokenize(input.route);
+  const codeTokens = tokenize(input.code).slice(0, 250);
+  const tokens = [.../* @__PURE__ */ new Set([...queryTokens, ...routeTokens, ...codeTokens])];
+  const text = candidateText(candidate);
+  const reasons = [];
+  const matchedTerms = /* @__PURE__ */ new Set();
+  let score = 0;
+  const highMatches = fieldMatches(tokens, text.high);
+  if (highMatches.length > 0) {
+    score += highMatches.length * 18;
+    for (const term of highMatches) matchedTerms.add(term);
+    addReason(reasons, "matched slug, name, alias, category, or domain");
+  }
+  const mediumMatches = fieldMatches(tokens, text.medium);
+  if (mediumMatches.length > 0) {
+    score += mediumMatches.length * 10;
+    for (const term of mediumMatches) matchedTerms.add(term);
+    addReason(
+      reasons,
+      "matched description, tags, components, interactions, visual brief, or layout hints"
+    );
+  }
+  const lowMatches = fieldMatches(tokens, text.low);
+  if (lowMatches.length > 0) {
+    score += lowMatches.length * 4;
+    for (const term of lowMatches) matchedTerms.add(term);
+    addReason(reasons, "matched composition, motion, responsive, preset, or accessibility details");
+  }
+  const slug = (candidate.slug || candidate.id).toLowerCase();
+  const query = (input.query || "").toLowerCase();
+  if (query && (slug === query || candidate.name?.toLowerCase() === query)) {
+    score += 50;
+    addReason(reasons, "exact slug or name match");
+  } else if (query && slug.includes(query.replace(/\s+/g, "-"))) {
+    score += 28;
+    addReason(reasons, "direct slug phrase match");
+  }
+  for (const domain of inferDomainTerms(tokens)) {
+    const candidateDomainText = [text.high, text.medium, text.low].join(" ").toLowerCase();
+    const hits = domain.terms.filter((term) => candidateDomainText.includes(term));
+    if (hits.length > 0) {
+      score += Math.min(30, hits.length * 6);
+      for (const term of hits) matchedTerms.add(term);
+      addReason(reasons, `${domain.domain} domain language`);
+    }
+  }
+  if (input.route) {
+    const route = input.route.toLowerCase();
+    if (route.includes(slug) || slug.includes(route.replace(/^\//, "").replace(/\//g, "-"))) {
+      score += 16;
+      addReason(reasons, "route name resembles pattern slug");
+    }
+  }
+  if (input.code) {
+    const code = input.code.toLowerCase();
+    const codeHints = [
+      ["intersectionobserver", "scroll-reveal"],
+      ["avatar", "social profile or feed"],
+      ["like", "social engagement"],
+      ["upload", "upload flow"],
+      ['input type="file"', "upload flow"],
+      ["textarea", "form or chat input"],
+      ["message", "chat surface"],
+      ["grid", "grid composition"],
+      ["form", "form surface"]
+    ];
+    for (const [needle, label] of codeHints) {
+      if (code.includes(needle) && [text.high, text.medium, text.low].join(" ").toLowerCase().includes(label.split(" ")[0])) {
+        score += 8;
+        addReason(reasons, `source code hint: ${label}`);
+      }
+    }
+  }
+  return {
+    candidate,
+    score,
+    reasons,
+    matchedTerms: [...matchedTerms].sort()
+  };
+}
+function rankPatternCandidates(input, candidates) {
+  const limit = input.limit ?? 10;
+  return candidates.map((candidate) => scorePatternCandidate(input, candidate)).filter((match) => match.score > 0).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return (a.candidate.slug || a.candidate.id).localeCompare(b.candidate.slug || b.candidate.id);
+  }).slice(0, limit);
+}
+
 // src/pattern.ts
 function resolvePatternPreset(pattern, explicitPreset, themeDefaultPresets) {
   const presets = pattern.presets;
@@ -375,6 +632,95 @@ function resolvePatternPreset(pattern, explicitPreset, themeDefaultPresets) {
   return { preset: presetName, layout: preset.layout, code: preset.code };
 }
 
+// src/types.ts
+var BLUEPRINT_PORTFOLIO_VISIBILITIES = [
+  "featured",
+  "public",
+  "labs",
+  "hidden"
+];
+var BLUEPRINT_PORTFOLIO_MATURITIES = [
+  "certified-flagship",
+  "supported-contract",
+  "experimental",
+  "fold-candidate",
+  "legacy-hidden"
+];
+var BLUEPRINT_ARTIFACT_STATUSES = ["none", "planned", "candidate", "certified"];
+var PUBLIC_BLUEPRINT_SETS = ["all", "featured", "certified", "labs"];
+function isBlueprintPortfolioVisibility(value) {
+  return BLUEPRINT_PORTFOLIO_VISIBILITIES.includes(value);
+}
+function isBlueprintPortfolioMaturity(value) {
+  return BLUEPRINT_PORTFOLIO_MATURITIES.includes(value);
+}
+function isBlueprintArtifactStatus(value) {
+  return BLUEPRINT_ARTIFACT_STATUSES.includes(value);
+}
+function isPublicBlueprintSet(value) {
+  return PUBLIC_BLUEPRINT_SETS.includes(value);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getBlueprintPortfolioMetadata(value) {
+  const candidate = isRecord3(value) && isRecord3(value.blueprint_portfolio) ? value.blueprint_portfolio : value;
+  if (!isRecord3(candidate)) {
+    return null;
+  }
+  const artifact = candidate.artifact;
+  if (!isBlueprintPortfolioVisibility(candidate.visibility) || !isBlueprintPortfolioMaturity(candidate.maturity) || typeof candidate.rationale !== "string" || !isRecord3(artifact) || !isBlueprintArtifactStatus(artifact.status)) {
+    return null;
+  }
+  return {
+    visibility: candidate.visibility,
+    maturity: candidate.maturity,
+    rationale: candidate.rationale,
+    recommended_alternative: typeof candidate.recommended_alternative === "string" ? candidate.recommended_alternative : void 0,
+    artifact: {
+      status: artifact.status,
+      showcase: typeof artifact.showcase === "string" ? artifact.showcase : void 0,
+      notes: typeof artifact.notes === "string" ? artifact.notes : void 0
+    }
+  };
+}
+var CONTENT_TYPES = ["pattern", "theme", "blueprint", "archetype", "shell"];
+var API_CONTENT_TYPES = [
+  "patterns",
+  "themes",
+  "blueprints",
+  "archetypes",
+  "shells"
+];
+var CONTENT_TYPE_TO_API_CONTENT_TYPE = {
+  pattern: "patterns",
+  theme: "themes",
+  blueprint: "blueprints",
+  archetype: "archetypes",
+  shell: "shells"
+};
+var API_CONTENT_TYPE_TO_CONTENT_TYPE = {
+  patterns: "pattern",
+  themes: "theme",
+  blueprints: "blueprint",
+  archetypes: "archetype",
+  shells: "shell"
+};
+function isContentType(value) {
+  return CONTENT_TYPES.includes(value);
+}
+function isApiContentType(value) {
+  return API_CONTENT_TYPES.includes(value);
+}
+var PUBLIC_CONTENT_SOURCES = ["official", "community", "organization"];
+function isPublicContentSource(value) {
+  return PUBLIC_CONTENT_SOURCES.includes(value);
+}
+var CONTENT_INTELLIGENCE_SOURCES = ["authored", "benchmark", "hybrid"];
+function isContentIntelligenceSource(value) {
+  return CONTENT_INTELLIGENCE_SOURCES.includes(value);
+}
+
 // src/ranking.ts
 function verificationScore(status) {
   switch (status) {
@@ -420,6 +766,18 @@ function confidenceTierScore(tier) {
 function getRecommendedPriority(item) {
   const intelligence = item.intelligence;
   let score = 0;
+  const portfolio = getBlueprintPortfolioMetadata(item.blueprint_portfolio);
+  if (portfolio?.visibility === "featured") {
+    score += 900;
+  }
+  if (portfolio?.artifact.status === "certified") {
+    score += 650;
+  } else if (portfolio?.artifact.status === "candidate") {
+    score += 120;
+  }
+  if (portfolio?.visibility === "labs" || portfolio?.visibility === "hidden") {
+    score -= 400;
+  }
   if (!intelligence) {
     return score;
   }
@@ -522,44 +880,6 @@ function createResolver(options) {
   };
 }
 
-// src/types.ts
-var CONTENT_TYPES = ["pattern", "theme", "blueprint", "archetype", "shell"];
-var API_CONTENT_TYPES = [
-  "patterns",
-  "themes",
-  "blueprints",
-  "archetypes",
-  "shells"
-];
-var CONTENT_TYPE_TO_API_CONTENT_TYPE = {
-  pattern: "patterns",
-  theme: "themes",
-  blueprint: "blueprints",
-  archetype: "archetypes",
-  shell: "shells"
-};
-var API_CONTENT_TYPE_TO_CONTENT_TYPE = {
-  patterns: "pattern",
-  themes: "theme",
-  blueprints: "blueprint",
-  archetypes: "archetype",
-  shells: "shell"
-};
-function isContentType(value) {
-  return CONTENT_TYPES.includes(value);
-}
-function isApiContentType(value) {
-  return API_CONTENT_TYPES.includes(value);
-}
-var PUBLIC_CONTENT_SOURCES = ["official", "community", "organization"];
-function isPublicContentSource(value) {
-  return PUBLIC_CONTENT_SOURCES.includes(value);
-}
-var CONTENT_INTELLIGENCE_SOURCES = ["authored", "benchmark", "hybrid"];
-function isContentIntelligenceSource(value) {
-  return CONTENT_INTELLIGENCE_SOURCES.includes(value);
-}
-
 // src/wiring.ts
 var WIRING_RULES = [
   {
@@ -702,9 +1022,13 @@ function classifySignal(signal) {
 export {
   API_CONTENT_TYPES,
   API_CONTENT_TYPE_TO_CONTENT_TYPE,
+  BLUEPRINT_ARTIFACT_STATUSES,
+  BLUEPRINT_PORTFOLIO_MATURITIES,
+  BLUEPRINT_PORTFOLIO_VISIBILITIES,
   CONTENT_INTELLIGENCE_SOURCES,
   CONTENT_TYPES,
   CONTENT_TYPE_TO_API_CONTENT_TYPE,
+  PUBLIC_BLUEPRINT_SETS,
   PUBLIC_CONTENT_SOURCES,
   RegistryAPIClient,
   RegistryAPIError,
@@ -715,12 +1039,20 @@ export {
   createResolver,
   deriveIOWirings,
   detectWirings,
+  getBlueprintPortfolioMetadata,
   isApiContentType,
+  isBlueprintArtifactStatus,
+  isBlueprintPortfolioMaturity,
+  isBlueprintPortfolioVisibility,
   isContentIntelligenceSource,
   isContentType,
+  isPublicBlueprintSet,
   isPublicContentSource,
   normalizePublicContentSort,
+  patternToDiscoveryCandidate,
+  rankPatternCandidates,
   resolvePatternPreset,
+  scorePatternCandidate,
   sortPublicContent
 };
 //# sourceMappingURL=index.js.map