@decantr/registry 1.0.0-beta.8 → 1.0.0

package/dist/client.js

@@ -0,0 +1,540 @@
+// 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/api-client.ts
+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;
+  }
+  // ── HTTP helpers ──
+  buildHeaders() {
+    const headers = {
+      "Accept": "application/json"
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    return headers;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async request(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await this.fetchWithTimeout(url, {
+      ...init,
+      headers: { ...this.buildHeaders(), ...init?.headers }
+    });
+    if (!response.ok) {
+      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();
+  }
+  // ── Cache helpers ──
+  getCached(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.cacheTtlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  setCache(key, data) {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // ── Health ──
+  async checkHealth() {
+    try {
+      const url = this.baseUrl.replace(/\/v1$/, "/health");
+      const response = await this.fetchWithTimeout(url);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  // ── Content fetching (public) ──
+  async listContent(type, params) {
+    const cacheKey = `list:${type}:${JSON.stringify(params ?? {})}`;
+    const cached = this.getCached(cacheKey);
+    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();
+    const path = `/${type}${query ? `?${query}` : ""}`;
+    const result = await this.request(path);
+    this.setCache(cacheKey, result);
+    return result;
+  }
+  async getContent(type, namespace, slug) {
+    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;
+  }
+  // ── Typed convenience methods ──
+  async getPattern(namespace, slug) {
+    return this.getContent("patterns", namespace, slug);
+  }
+  async getArchetype(namespace, slug) {
+    return this.getContent("archetypes", namespace, slug);
+  }
+  async getTheme(namespace, slug) {
+    return this.getContent("themes", namespace, slug);
+  }
+  async getBlueprint(namespace, slug) {
+    return this.getContent("blueprints", namespace, slug);
+  }
+  async getShell(namespace, slug) {
+    return this.getContent("shells", namespace, slug);
+  }
+  // ── Search ──
+  async search(params) {
+    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");
+  }
+  async publishContent(payload) {
+    return this.request("/content", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  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";
+  return {
+    async search(query, type) {
+      const params = new URLSearchParams({ q: query });
+      if (type) params.set("type", type);
+      const res = await fetch(`${baseUrl}/search?${params}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      if (Array.isArray(data)) return data;
+      return data.results ?? [];
+    },
+    async fetch(type, id, version) {
+      const url = version ? `${baseUrl}/content/${type}/${id}/${version}` : `${baseUrl}/content/${type}/${id}`;
+      const res = await fetch(url);
+      if (!res.ok) return null;
+      return res.json();
+    }
+  };
+}
+
+// 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,
+  comparePublicContent,
+  createRegistryClient,
+  isApiContentType,
+  isContentIntelligenceSource,
+  isContentType,
+  isPublicContentSource,
+  normalizePublicContentSort,
+  sortPublicContent
+};
+//# sourceMappingURL=client.js.map