@decantr/registry 1.0.0-beta.8 → 1.0.0

package/dist/index.js

@@ -1,12 +1,64 @@
+// 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/resolver.ts
 import { readFile } from "fs/promises";
 import { join } from "path";
 var TYPE_DIRS = {
   pattern: "patterns",
   archetype: "archetypes",
-  recipe: "recipes",
   theme: "themes",
-  blueprint: "blueprints"
+  blueprint: "blueprints",
+  shell: "shells"
 };
 async function tryLoadJson(filePath) {
   try {
@@ -39,7 +91,7 @@ function createResolver(options) {
 }
 
 // src/pattern.ts
-function resolvePatternPreset(pattern, explicitPreset, recipeDefaultPresets) {
+function resolvePatternPreset(pattern, explicitPreset, themeDefaultPresets) {
   const presets = pattern.presets;
   const hasPresets = Object.keys(presets).length > 0;
   if (!hasPresets) {
@@ -51,9 +103,9 @@ function resolvePatternPreset(pattern, explicitPreset, recipeDefaultPresets) {
   }
   let presetName = explicitPreset;
   if (presetName && !presets[presetName]) presetName = void 0;
-  if (!presetName && recipeDefaultPresets?.[pattern.id]) {
-    const recipeName = recipeDefaultPresets[pattern.id];
-    if (presets[recipeName]) presetName = recipeName;
+  if (!presetName && themeDefaultPresets?.[pattern.id]) {
+    const themeName = themeDefaultPresets[pattern.id];
+    if (presets[themeName]) presetName = themeName;
   }
   if (!presetName) presetName = pattern.default_preset;
   if (!presetName || !presets[presetName]) presetName = Object.keys(presets)[0];
@@ -209,15 +261,36 @@ function classifySignal(signal) {
 var DEFAULT_BASE_URL = "https://api.decantr.ai/v1";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+function unwrapDataEnvelope(value) {
+  if (typeof value === "object" && value !== null && "data" in value) {
+    return value.data;
+  }
+  return value;
+}
+var RegistryAPIError = class extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.name = "RegistryAPIError";
+    this.status = status;
+    this.details = details;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 var RegistryAPIClient = class {
   baseUrl;
   apiKey;
+  accessToken;
   timeoutMs;
   cacheTtlMs;
   cache = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
     this.apiKey = options.apiKey;
+    this.accessToken = options.accessToken;
     this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
   }
@@ -229,6 +302,9 @@ var RegistryAPIClient = class {
     if (this.apiKey) {
       headers["X-API-Key"] = this.apiKey;
     }
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
     return headers;
   }
   async fetchWithTimeout(url, init) {
@@ -247,8 +323,22 @@ var RegistryAPIClient = class {
       headers: { ...this.buildHeaders(), ...init?.headers }
     });
     if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(`API ${response.status}: ${body || response.statusText}`);
+      const bodyText = await response.text().catch(() => "");
+      let details;
+      let message = response.statusText;
+      if (bodyText) {
+        try {
+          details = JSON.parse(bodyText);
+          if (isRecord(details) && typeof details.error === "string") {
+            message = details.error;
+          } else {
+            message = bodyText;
+          }
+        } catch {
+          message = bodyText;
+        }
+      }
+      throw new RegistryAPIError(response.status, `API ${response.status}: ${message}`, details);
     }
     return response.json();
   }
@@ -285,6 +375,10 @@ var RegistryAPIClient = class {
     if (cached) return cached;
     const searchParams = new URLSearchParams();
     if (params?.namespace) searchParams.set("namespace", params.namespace);
+    if (params?.source) searchParams.set("source", params.source);
+    if (params?.sort) searchParams.set("sort", params.sort);
+    if (params?.recommended) searchParams.set("recommended", "true");
+    if (params?.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
     if (params?.limit) searchParams.set("limit", String(params.limit));
     if (params?.offset) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
@@ -297,6 +391,23 @@ var RegistryAPIClient = class {
     const cacheKey = `get:${type}:${namespace}:${slug}`;
     const cached = this.getCached(cacheKey);
     if (cached) return cached;
+    const raw = await this.request(`/${type}/${namespace}/${slug}`);
+    const unwrapped = unwrapDataEnvelope(raw);
+    this.setCache(cacheKey, unwrapped);
+    return unwrapped;
+  }
+  async getPublicContentRecord(type, namespace, slug) {
+    const cacheKey = `public-record:${type}:${namespace}:${slug}`;
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const result = await this.request(`/${type}/${namespace}/${slug}`);
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getContentRecord(type, namespace, slug) {
+    const cacheKey = `content-record:${type}:${namespace}:${slug}:${this.apiKey ?? ""}:${this.accessToken ?? ""}`;
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
     const result = await this.request(`/${type}/${namespace}/${slug}`);
     this.setCache(cacheKey, result);
     return result;
@@ -308,9 +419,6 @@ var RegistryAPIClient = class {
   async getArchetype(namespace, slug) {
     return this.getContent("archetypes", namespace, slug);
   }
-  async getRecipe(namespace, slug) {
-    return this.getContent("recipes", namespace, slug);
-  }
   async getTheme(namespace, slug) {
     return this.getContent("themes", namespace, slug);
   }
@@ -325,10 +433,41 @@ var RegistryAPIClient = class {
     const searchParams = new URLSearchParams({ q: params.q });
     if (params.type) searchParams.set("type", params.type);
     if (params.namespace) searchParams.set("namespace", params.namespace);
+    if (params.source) searchParams.set("source", params.source);
+    if (params.sort) searchParams.set("sort", params.sort);
+    if (params.recommended) searchParams.set("recommended", "true");
+    if (params.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
     if (params.limit) searchParams.set("limit", String(params.limit));
     if (params.offset) searchParams.set("offset", String(params.offset));
     return this.request(`/search?${searchParams}`);
   }
+  async getPublicUserProfile(username) {
+    const cacheKey = `public-user:${username}`;
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const result = await this.request(`/users/${encodeURIComponent(username)}`);
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getPublicUserContent(username, params) {
+    const cacheKey = `public-user-content:${username}:${JSON.stringify(params ?? {})}`;
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const searchParams = new URLSearchParams();
+    if (params?.type) searchParams.set("type", params.type);
+    if (params?.source) searchParams.set("source", params.source);
+    if (params?.sort) searchParams.set("sort", params.sort);
+    if (params?.recommended) searchParams.set("recommended", "true");
+    if (params?.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params?.limit != null) searchParams.set("limit", String(params.limit));
+    if (params?.offset != null) searchParams.set("offset", String(params.offset));
+    const query = searchParams.toString();
+    const result = await this.request(
+      `/users/${encodeURIComponent(username)}/content${query ? `?${query}` : ""}`
+    );
+    this.setCache(cacheKey, result);
+    return result;
+  }
   // ── Authenticated endpoints ──
   async getProfile() {
     return this.request("/me");
@@ -343,10 +482,122 @@ var RegistryAPIClient = class {
   async getMyContent() {
     return this.request("/my/content");
   }
+  async getAccessiblePrivateContent(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.type) searchParams.set("type", params.type);
+    if (params?.scope) searchParams.set("scope", params.scope);
+    if (params?.q) searchParams.set("q", params.q);
+    if (params?.limit != null) searchParams.set("limit", String(params.limit));
+    if (params?.offset != null) searchParams.set("offset", String(params.offset));
+    const query = searchParams.toString();
+    return this.request(
+      `/private/content${query ? `?${query}` : ""}`
+    );
+  }
   // ── Schema ──
   async getSchema(name = "essence.v3.json") {
     return this.request(`/schema/${name}`);
   }
+  // ── Showcase benchmarks ──
+  async getShowcaseManifest() {
+    const cacheKey = "showcase:manifest";
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const result = await this.request("/showcase/manifest");
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getShowcaseShortlist() {
+    const cacheKey = "showcase:shortlist";
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const result = await this.request("/showcase/shortlist");
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getShowcaseShortlistVerification() {
+    const cacheKey = "showcase:shortlist-verification";
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const result = await this.request("/showcase/shortlist-verification");
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getRegistryIntelligenceSummary(params) {
+    const cacheKey = `registry-intelligence-summary:${JSON.stringify(params ?? {})}`;
+    const cached = this.getCached(cacheKey);
+    if (cached) return cached;
+    const searchParams = new URLSearchParams();
+    if (params?.namespace) searchParams.set("namespace", params.namespace);
+    const query = searchParams.toString();
+    const result = await this.request(
+      `/intelligence/summary${query ? `?${query}` : ""}`
+    );
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async compileExecutionPacks(essence, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.namespace) searchParams.set("namespace", params.namespace);
+    const query = searchParams.toString();
+    return this.request(
+      `/packs/compile${query ? `?${query}` : ""}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(essence)
+      }
+    );
+  }
+  async selectExecutionPack(input, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.namespace) searchParams.set("namespace", params.namespace);
+    const query = searchParams.toString();
+    return this.request(
+      `/packs/select${query ? `?${query}` : ""}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      }
+    );
+  }
+  async getExecutionPackManifest(essence, params) {
+    const selected = await this.selectExecutionPack(
+      {
+        essence,
+        pack_type: "scaffold"
+      },
+      params
+    );
+    return selected.manifest;
+  }
+  async critiqueFile(input, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.namespace) searchParams.set("namespace", params.namespace);
+    const query = searchParams.toString();
+    return this.request(
+      `/critique/file${query ? `?${query}` : ""}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      }
+    );
+  }
+  async auditProject(input, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.namespace) searchParams.set("namespace", params.namespace);
+    const query = searchParams.toString();
+    return this.request(
+      `/audit/project${query ? `?${query}` : ""}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      }
+    );
+  }
 };
 function createRegistryClient(options = {}) {
   const baseUrl = options.baseUrl ?? "https://api.decantr.ai/v1";
@@ -368,14 +619,135 @@ function createRegistryClient(options = {}) {
     }
   };
 }
+
+// src/ranking.ts
+function verificationScore(status) {
+  switch (status) {
+    case "smoke-green":
+      return 200;
+    case "build-green":
+      return 120;
+    case "pending":
+      return 20;
+    case "smoke-red":
+    case "build-red":
+      return -40;
+    default:
+      return 0;
+  }
+}
+function confidenceScore(level) {
+  switch (level) {
+    case "high":
+      return 120;
+    case "medium":
+      return 70;
+    case "low":
+      return 30;
+    default:
+      return 0;
+  }
+}
+function confidenceTierScore(tier) {
+  switch (tier) {
+    case "verified":
+      return 180;
+    case "high":
+      return 120;
+    case "medium":
+      return 60;
+    case "low":
+      return 10;
+    default:
+      return 0;
+  }
+}
+function getRecommendedPriority(item) {
+  const intelligence = item.intelligence;
+  let score = 0;
+  if (!intelligence) {
+    return score;
+  }
+  if (intelligence.recommended) {
+    score += 500;
+  }
+  if (intelligence.golden_usage === "shortlisted") {
+    score += 160;
+  } else if (intelligence.golden_usage === "showcase") {
+    score += 80;
+  }
+  score += verificationScore(intelligence.verification_status);
+  score += confidenceScore(intelligence.benchmark_confidence);
+  score += confidenceTierScore(intelligence.confidence_tier);
+  score += Math.round((intelligence.confidence_score ?? 0) / 2);
+  score += intelligence.quality_score ?? 0;
+  return score;
+}
+function normalizePublicContentSort(value) {
+  switch (value) {
+    case "popular":
+    case "recommended":
+      return "recommended";
+    case "newest":
+    case "recent":
+    case "published":
+      return "recent";
+    case "name":
+      return "name";
+    default:
+      return "recommended";
+  }
+}
+function comparePublicContent(a, b, sort = "recommended") {
+  if (sort === "name") {
+    return (a.name ?? a.slug).localeCompare(b.name ?? b.slug);
+  }
+  if (sort === "recent") {
+    const publishedDelta2 = new Date(b.published_at ?? 0).getTime() - new Date(a.published_at ?? 0).getTime();
+    if (publishedDelta2 !== 0) {
+      return publishedDelta2;
+    }
+    return a.slug.localeCompare(b.slug);
+  }
+  const priorityDelta = getRecommendedPriority(b) - getRecommendedPriority(a);
+  if (priorityDelta !== 0) {
+    return priorityDelta;
+  }
+  if (a.namespace !== b.namespace) {
+    if (a.namespace === "@official") return -1;
+    if (b.namespace === "@official") return 1;
+  }
+  const publishedDelta = new Date(b.published_at ?? 0).getTime() - new Date(a.published_at ?? 0).getTime();
+  if (publishedDelta !== 0) {
+    return publishedDelta;
+  }
+  return (a.name ?? a.slug).localeCompare(b.name ?? b.slug);
+}
+function sortPublicContent(items, sort = "recommended") {
+  return [...items].sort((left, right) => comparePublicContent(left, right, sort));
+}
 export {
+  API_CONTENT_TYPES,
+  API_CONTENT_TYPE_TO_CONTENT_TYPE,
+  CONTENT_INTELLIGENCE_SOURCES,
+  CONTENT_TYPES,
+  CONTENT_TYPE_TO_API_CONTENT_TYPE,
+  PUBLIC_CONTENT_SOURCES,
   RegistryAPIClient,
+  RegistryAPIError,
   WIRING_RULES,
   buildIOMap,
+  comparePublicContent,
   createRegistryClient,
   createResolver,
   deriveIOWirings,
   detectWirings,
-  resolvePatternPreset
+  isApiContentType,
+  isContentIntelligenceSource,
+  isContentType,
+  isPublicContentSource,
+  normalizePublicContentSort,
+  resolvePatternPreset,
+  sortPublicContent
 };
 //# sourceMappingURL=index.js.map