youiyoux 0.1.13 → 0.1.14

package/dist/chunks/{chunk-ZOQW6LNH.js → chunk-TPP4HLDB.js}

@@ -6,15 +6,19 @@ import {
   openStore,
   pageInteger,
   searchTerms
-} from "./chunk-ZWVWENSB.js";
+} from "./chunk-A2IZOTJG.js";
 import {
   LIBRARY_SOURCE_KINDS,
   LibraryEntry,
   copyleft,
   external_exports,
+  require_dist,
   sha256,
   writeFileAtomic
-} from "./chunk-NF4OJYKC.js";
+} from "./chunk-S7UN5KQK.js";
+import {
+  __toESM
+} from "./chunk-WNTS7ZO4.js";
 
 // ../discover/src/aliases.ts
 var CONCEPTS = [
@@ -63,11 +67,11 @@ var CONCEPTS = [
   { id: "marquee", names: ["marquee", "ticker", "scrolling text"], packages: [] }
 ];
 var BY_ID = new Map(CONCEPTS.map((c) => [c.id, c]));
-function normalize(text) {
-  return text.normalize("NFC").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+function normalize(text2) {
+  return text2.normalize("NFC").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
 }
-function hasPhrase(text, phrase) {
-  return ` ${text} `.includes(` ${phrase} `);
+function hasPhrase(text2, phrase) {
+  return ` ${text2} `.includes(` ${phrase} `);
 }
 var STOP = /* @__PURE__ */ new Set(["a", "an", "the", "for", "with", "and", "or", "of", "to", "in", "component", "components", "ui", "react"]);
 function readNeed(need) {
@@ -106,8 +110,8 @@ function publicHttps(value) {
 }
 
 // ../discover/src/text.ts
-function cleanText(text) {
-  return text.replace(/(?:\x1b\]|\x9d)[\s\S]*?(?:\x07|\x1b\\|\x9c|$)/g, "").replace(/(?:\x1b[PX^_]|[\x90\x98\x9e\x9f])[\s\S]*?(?:\x1b\\|\x9c|$)/g, "").replace(/(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[ -/]*[0-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+function cleanText(text2) {
+  return text2.replace(/(?:\x1b\]|\x9d)[\s\S]*?(?:\x07|\x1b\\|\x9c|$)/g, "").replace(/(?:\x1b[PX^_]|[\x90\x98\x9e\x9f])[\s\S]*?(?:\x1b\\|\x9c|$)/g, "").replace(/(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[ -/]*[0-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
 }
 function cleanData(value) {
   if (typeof value === "string") return cleanText(value);
@@ -245,8 +249,8 @@ function nameSlug(name) {
   return slug || "item";
 }
 function summaryOf(...texts) {
-  const text = texts.map((t) => cleanText(t ?? "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim()).find((t) => t.length > 0) ?? "";
-  return text.length > 200 ? `${text.slice(0, 199)}\u2026` : text;
+  const text2 = texts.map((t) => cleanText(t ?? "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim()).find((t) => t.length > 0) ?? "";
+  return text2.length > 200 ? `${text2.slice(0, 199)}\u2026` : text2;
 }
 function categoriesOf(item, headless) {
   const own = (item.categories ?? []).map((c) => c.toLowerCase());
@@ -347,8 +351,8 @@ function githubRepo(url) {
   return match ? `${match[1]}/${match[2]}` : null;
 }
 function answers(object, concept) {
-  const text = normalize([object.package.name, object.package.description ?? "", ...object.package.keywords ?? []].join(" "));
-  return concept.packages.includes(object.package.name) || concept.names.some((name) => hasPhrase(text, normalize(name)));
+  const text2 = normalize([object.package.name, object.package.description ?? "", ...object.package.keywords ?? []].join(" "));
+  return concept.packages.includes(object.package.name) || concept.names.some((name) => hasPhrase(text2, normalize(name)));
 }
 var MIN_WEEKLY_DOWNLOADS = 1e3;
 function npmCandidates(concept, objects) {
@@ -624,9 +628,10 @@ var PoliteClient = class {
     return this.options.now?.() ?? /* @__PURE__ */ new Date();
   }
   /** Replace the token wherever it appears, so no message, log line or file can carry it. */
-  redact(text) {
-    const token = this.options.token;
-    return cleanText(token ? text.split(token).join("***") : text);
+  redact(text2) {
+    let clean = text2;
+    for (const token of [this.options.token, this.options.figmaToken]) if (token) clean = clean.split(token).join("***");
+    return cleanText(clean);
   }
   /** True when the bucket still has room in its window; a spent bucket stays spent for this run. */
   take(bucket) {
@@ -670,7 +675,7 @@ var PoliteClient = class {
     const gate = host;
     const request = () => this.gate.run(
       () => gate.run(async () => {
-        if (npm && this.npmStarted) await (this.options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))))(500);
+        if (npm && this.npmStarted) await (this.options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))))(500);
         if (npm) this.npmStarted = true;
         if (!this.take(bucket)) {
           this.stats.rateLimited++;
@@ -680,7 +685,7 @@ var PoliteClient = class {
           const result = await this.send(url, parsed, bucket, accept);
           if (!npm || result.ok || result.status !== 429) return result;
           if (attempt === 4) return result;
-          await (this.options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))))(Math.max(result.retryAfterMs ?? 0, Math.min(3e4, 1e3 * 2 ** attempt * (0.5 + (this.options.random ?? Math.random)()))));
+          await (this.options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))))(Math.max(result.retryAfterMs ?? 0, Math.min(3e4, 1e3 * 2 ** attempt * (0.5 + (this.options.random ?? Math.random)()))));
         }
       })
     );
@@ -692,6 +697,7 @@ var PoliteClient = class {
     if (cached?.etag) headers["if-none-match"] = cached.etag;
     if (cached?.lastModified) headers["if-modified-since"] = cached.lastModified;
     if (this.options.token && parsed.hostname === "api.github.com") headers.authorization = `Bearer ${this.options.token}`;
+    if (this.options.figmaToken && parsed.hostname === "api.figma.com") headers["x-figma-token"] = this.options.figmaToken;
     this.stats.sent++;
     this.inFlight++;
     this.stats.maxInFlight = Math.max(this.stats.maxInFlight, this.inFlight);
@@ -912,10 +918,10 @@ function rankEntries(entries, need, options = {}) {
     const f = fieldsOf(entry);
     if (options.role && !playsRole(options.role, f)) continue;
     const why = [];
-    let text = 0;
-    for (const concept of read.concepts) text += conceptScore(concept, f, why);
-    for (const word of read.words) text += wordScore(word, f, why);
-    if (text <= 0) continue;
+    let text2 = 0;
+    for (const concept of read.concepts) text2 += conceptScore(concept, f, why);
+    for (const word of read.words) text2 += wordScore(word, f, why);
+    if (text2 <= 0) continue;
     let suitability = 1;
     if (isIconEntry(entry)) {
       suitability *= 0.3;
@@ -926,7 +932,7 @@ function rankEntries(entries, need, options = {}) {
       suitability *= 0.3;
       why.push(`framework ${framework}`);
     }
-    scored.push({ entry, score: (text * KIND_WEIGHT[entry.kind] + signalBoost(entry)) * suitability, why });
+    scored.push({ entry, score: (text2 * KIND_WEIGHT[entry.kind] + signalBoost(entry)) * suitability, why });
   }
   scored.sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id));
   return { need, concepts: read.concepts.map((c) => c.id), scored };
@@ -1751,8 +1757,8 @@ async function preparePreview(cacheDir, id, options = {}) {
   const queue = [...own];
   while (queue.length > 0) {
     const file = queue.shift();
-    const text = texts.get(file);
-    for (const match of text.matchAll(SPECIFIER)) {
+    const text2 = texts.get(file);
+    for (const match of text2.matchAll(SPECIFIER)) {
       const spec = match[3];
       if (!spec.startsWith("@/registry/") || resolved.has(spec)) continue;
       const local = [...texts.keys()].find((f) => f.replace(/\.(?:tsx?|jsx?)$/, "") === spec.slice(2) || f.replace(/\/index\.(?:tsx?|jsx?)$/, "") === spec.slice(2));
@@ -1793,17 +1799,17 @@ async function preparePreview(cacheDir, id, options = {}) {
     }
   }
   const rewritten = /* @__PURE__ */ new Map();
-  for (const [file, text] of texts) {
-    rewritten.set(file, text.replace(SPECIFIER, (all, lead, quote, spec) => {
+  for (const [file, text2] of texts) {
+    rewritten.set(file, text2.replace(SPECIFIER, (all, lead, quote, spec) => {
       const target = resolved.get(spec);
       if (!target || target === spec) return all;
       const next = target.startsWith("/") || /^[a-z]:[\\/]/i.test(target) ? target : relativeSpec(file, target);
       return `${lead}${quote}${next}${quote}`;
     }));
   }
-  for (const [file, text] of rewritten) {
+  for (const [file, text2] of rewritten) {
     await assertNoLinks(dir, file);
-    await writeFileAtomic(join5(dir, file), text);
+    await writeFileAtomic(join5(dir, file), text2);
   }
   const packages = [...new Set([...rewritten.values()].flatMap((t) => importedPackages(t)))].sort();
   const declared = [...new Set([...source.dependencies ?? entry.install?.npm ?? [], ...partDeps].map(packageName))].sort();
@@ -1955,6 +1961,407 @@ async function buildGaps(source, store) {
   };
 }
 
+// ../discover/src/ingest.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename as basename2, resolve } from "node:path";
+
+// ../discover/src/ingest-design-md.ts
+var import_yaml = __toESM(require_dist(), 1);
+import { basename } from "node:path";
+var GROUP_TITLE = { colors: "Colors", typography: "Typography", rounded: "Corner radius", spacing: "Spacing", elevation: "Elevation", shadows: "Shadows", motion: "Motion" };
+var NOT_TOKENS = /* @__PURE__ */ new Set(["name", "version", "description", "components", "$schema"]);
+var SAMPLES = 4;
+var title = (key) => key.split(/[-_\s]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+function sample(name, value) {
+  if (value && typeof value === "object") {
+    const v = value;
+    return `${name} ${[v.fontSize, v.lineHeight, v.fontWeight].filter((x) => x !== void 0).join("/")}`.trim();
+  }
+  return `${name} ${String(value)}`;
+}
+function bodyComponents(body) {
+  const lines = body.split(/\r?\n/);
+  const found = [];
+  let level = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const heading = /^(#{1,6})\s+(.+?)\s*#*$/.exec(lines[i]);
+    if (heading) {
+      const depth = heading[1].length;
+      if (/\bcomponents?\b/i.test(heading[2])) {
+        level = depth;
+        continue;
+      }
+      if (level > 0 && depth <= level) level = 0;
+      else if (level > 0 && depth > level) {
+        const text2 = lines.slice(i + 1).find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("|"));
+        found.push({ name: heading[2].replace(/[`*_]/g, ""), summary: text2?.trim() ?? "" });
+      }
+      continue;
+    }
+    if (level === 0) continue;
+    const row = /^\|(.+)\|\s*$/.exec(lines[i]);
+    if (!row || /^\|[\s:-]+\|/.test(lines[i])) continue;
+    const cells = row[1].split("|").map((c) => c.trim());
+    const name = cells[0].replace(/[`*_]/g, "");
+    if (!name || /^(component|name|element)s?$/i.test(name)) continue;
+    found.push({ name, summary: cells.slice(1).filter((c) => c && c !== "\u2014" && !c.startsWith("`")).at(-1) ?? "" });
+  }
+  return found;
+}
+async function readDesignMd(target, client, fetchedAt, readLocal) {
+  const text2 = target.local ? await readLocal(target.location).then((body2) => ({ body: body2, sha256: digestOf(body2) }), () => {
+    throw new IngestError(`could not read ${basename(target.location)}`);
+  }) : await fetchText(client, target.location, "the DESIGN.md");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text2.body);
+  let front = {};
+  if (match) {
+    try {
+      const parsed = (0, import_yaml.parse)(match[1]);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) front = parsed;
+    } catch (error) {
+      throw new IngestError(`the DESIGN.md's frontmatter is not YAML: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+    }
+  }
+  const body = match ? match[2] : text2.body;
+  const heading = /^#\s+(.+)$/m.exec(body)?.[1]?.replace(/^Design System:\s*/i, "").trim();
+  const name = typeof front.name === "string" && front.name.trim() || heading || (target.local ? basename(target.location, ".md") : new URL(target.location).host);
+  const url = target.local ? null : target.location;
+  const source = { kind: "design-md", name, url };
+  const file = target.local ? basename(target.location) : new URL(target.location).pathname.split("/").at(-1) ?? "DESIGN.md";
+  const inputs = [];
+  for (const [group, value] of Object.entries(front)) {
+    if (NOT_TOKENS.has(group) || !value || typeof value !== "object" || Array.isArray(value)) continue;
+    const tokens = Object.entries(value);
+    if (tokens.length === 0) continue;
+    const samples = tokens.slice(0, SAMPLES).map(([k, v]) => sample(k, v)).join(", ");
+    inputs.push({ kind: "token", name: GROUP_TITLE[group] ?? title(group), summary: `${tokens.length} ${group} token${tokens.length === 1 ? "" : "s"}: ${samples}${tokens.length > SAMPLES ? ", \u2026" : ""}`, ref: `${file}#${group}`, url, digest: digestOf(value), categories: [group] });
+  }
+  const components = /* @__PURE__ */ new Map();
+  const keys = Object.keys(front.components ?? {});
+  for (const key of keys) {
+    const base = keys.filter((other) => other !== key && key.startsWith(`${other}-`)).sort((a, b) => a.length - b.length)[0] ?? key;
+    const entry = components.get(base.toLowerCase()) ?? { name: title(base), summary: "", digest: digestOf(front.components[base]) };
+    if (base !== key) entry.summary = `${entry.summary ? `${entry.summary}, ` : "Variants: "}${key.slice(base.length + 1)}`;
+    components.set(base.toLowerCase(), entry);
+  }
+  for (const found of bodyComponents(body)) {
+    const key = found.name.toLowerCase().replace(/\s+/g, "-");
+    const known = components.get(key);
+    components.set(key, { name: known?.name ?? found.name, summary: found.summary || known?.summary || "", digest: known?.digest ?? digestOf(found) });
+  }
+  for (const [key, c] of components) inputs.push({ kind: "component", name: c.name, summary: c.summary || `${c.name}, as ${name}'s DESIGN.md describes it`, ref: `${file}#${key}`, url, digest: c.digest });
+  if (inputs.length === 0) throw new IngestError(`the DESIGN.md names no token groups in its frontmatter and no components: nothing to read`);
+  return {
+    source,
+    license: "unknown",
+    entries: itemsOf(source, "unknown", fetchedAt, inputs),
+    skipped: [],
+    notes: ["licence unknown: a DESIGN.md does not say one", ...target.local ? ["read from a local file: its path is not written into the items"] : []]
+  };
+}
+
+// ../discover/src/ingest-figma.ts
+var API = "https://api.figma.com/v1";
+var STYLE_GROUP = { FILL: "Color styles", TEXT: "Text styles", EFFECT: "Effect styles", GRID: "Grid styles" };
+var SAMPLES2 = 5;
+var listOf = (value, field) => {
+  const list = value.meta?.[field];
+  return Array.isArray(list) ? list : [];
+};
+var text = (value) => typeof value === "string" ? value.trim() : "";
+async function readFigma(target, client, fetchedAt) {
+  const file = await fetchJson(client, `${API}/files/${target.key}?depth=1`, "the Figma file").catch((error) => {
+    throw new IngestError(`${error instanceof Error ? error.message : String(error)}: is FIGMA_TOKEN allowed to read this file?`);
+  });
+  const fileName = text(file.name) || target.key;
+  const [sets, components, styles] = await Promise.all([
+    fetchJson(client, `${API}/files/${target.key}/component_sets`, "its component sets"),
+    fetchJson(client, `${API}/files/${target.key}/components`, "its components"),
+    fetchJson(client, `${API}/files/${target.key}/styles`, "its styles")
+  ]);
+  const at = (node) => `https://www.figma.com/design/${target.key}?node-id=${encodeURIComponent(String(node).replace(/:/g, "-"))}`;
+  const source = { kind: "figma", name: `${fileName} (Figma)`, url: `https://www.figma.com/design/${target.key}` };
+  const inputs = [];
+  const page = (p) => [text(p.containing_frame?.pageName), text(p.containing_frame?.name)].filter(Boolean);
+  for (const set of listOf(sets, "component_sets")) {
+    if (!text(set.name)) continue;
+    inputs.push({ kind: "component", name: text(set.name), summary: text(set.description) || `${text(set.name)}, a component set in ${fileName}`, ref: text(set.key) || String(set.node_id), url: at(set.node_id), digest: digestOf(set), categories: page(set) });
+  }
+  const loose = listOf(components, "components").filter((c) => !c.containing_frame?.containingComponentSet && text(c.name));
+  for (const component of loose) inputs.push({ kind: "component", name: text(component.name), summary: text(component.description) || `${text(component.name)}, a component in ${fileName}`, ref: text(component.key) || String(component.node_id), url: at(component.node_id), digest: digestOf(component), categories: page(component) });
+  const byType = /* @__PURE__ */ new Map();
+  for (const style of listOf(styles, "styles")) {
+    const type = text(style.style_type);
+    if (type) byType.set(type, [...byType.get(type) ?? [], style]);
+  }
+  for (const [type, list] of byType) {
+    const names = list.map((s) => text(s.name)).filter(Boolean);
+    inputs.push({ kind: "token", name: STYLE_GROUP[type] ?? `${type.toLowerCase()} styles`, summary: `${names.length} ${(STYLE_GROUP[type] ?? type).toLowerCase()} in ${fileName}: ${names.slice(0, SAMPLES2).join(", ")}${names.length > SAMPLES2 ? ", \u2026" : ""}`, ref: `${target.key}#${type.toLowerCase()}`, url: source.url, digest: digestOf(list), categories: [type.toLowerCase()] });
+  }
+  if (inputs.length === 0) throw new IngestError(`${fileName} has no components or styles published to a team library: Figma lists only published ones, so publish the library (Assets > Libraries) and ingest it again`);
+  return {
+    source,
+    license: "unknown",
+    entries: itemsOf(source, "unknown", fetchedAt, inputs),
+    skipped: [],
+    notes: [`a Figma file: ${fileName}, ${listOf(sets, "component_sets").length} component sets, ${loose.length} other components, ${byType.size} kinds of style`, "only what is published to a team library is listed", "licence unknown: a Figma file does not say one"]
+  };
+}
+
+// ../discover/src/ingest-github.ts
+var API2 = "https://api.github.com";
+var COMPONENT_FILE = /\.(tsx|jsx|vue|svelte|astro)$/;
+var NOT_A_COMPONENT = /(\.(test|spec|stories|story|d)\.[^.]+$)|(^|\/)(index|types?|utils?|helpers?|constants?)\.[^.]+$|(^|\/)(__tests__|__mocks__|stories|examples?|demo|docs?)\//;
+var CONTRACTS_READ = 100;
+async function licenseOf(client, repo, fetchedAt) {
+  const got = await client.json(`${API2}/repos/${repo}/license`, false);
+  if (!got.ok) return "unknown";
+  const value = got.value;
+  const spdx = value.license?.spdx_id;
+  if (typeof spdx !== "string" || spdx === "NOASSERTION" || typeof value.html_url !== "string") return "unknown";
+  return { spdx, evidenceUrl: value.html_url, verifiedAt: fetchedAt };
+}
+async function readGithub(target, client, fetchedAt) {
+  const repo = `${target.owner}/${target.repo}`;
+  const meta = await fetchJson(client, `${API2}/repos/${repo}`, `the repository ${repo}`);
+  const ref = target.ref ?? meta.default_branch ?? "main";
+  const commit = (await fetchJson(client, `${API2}/repos/${repo}/commits/${encodeURIComponent(ref)}`, `${repo} at ${ref}`)).sha;
+  if (typeof commit !== "string" || !/^[0-9a-f]{40}$/.test(commit)) throw new IngestError(`${repo} has no commit at ${ref}`);
+  const tree = await fetchJson(client, `${API2}/repos/${repo}/git/trees/${commit}?recursive=1`, `${repo}'s files`);
+  const scope = target.path ? `${target.path.replace(/\/+$/, "")}/` : "";
+  const blobs = new Map((tree.tree ?? []).filter((e) => e.type === "blob" && e.path.startsWith(scope)).map((e) => [e.path, e.sha ?? null]));
+  const files = [...blobs.keys()];
+  const license = await licenseOf(client, repo, fetchedAt);
+  const source = { kind: "github", name: repo, url: `https://github.com/${repo}${target.ref || target.path ? `/tree/${ref}${target.path ? `/${target.path}` : ""}` : ""}` };
+  const blob = (path) => `https://github.com/${repo}/blob/${commit}/${path}`;
+  const raw = (path) => `https://raw.githubusercontent.com/${repo}/${commit}/${path}`;
+  const notes = [
+    `read at ${commit.slice(0, 7)} (${ref})`,
+    license === "unknown" ? "licence unknown: GitHub names none for this repository, so its items cannot be adopted until one is found" : `licence ${license.spdx}, from ${license.evidenceUrl}`,
+    ...tree.truncated ? ["GitHub listed only part of this repository's files: name a folder (https://github.com/<owner>/<repo>/tree/<ref>/<folder>) to read the rest"] : []
+  ];
+  const byDepth = (a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b);
+  const registry = files.filter((f) => /(^|\/)registry\.json$/.test(f) && !f.includes("node_modules/")).sort(byDepth)[0];
+  if (registry) {
+    const text2 = await fetchText(client, raw(registry), `${repo}'s ${registry}`);
+    let value;
+    try {
+      value = JSON.parse(text2.body);
+    } catch {
+      throw new IngestError(`${repo}'s ${registry} is not JSON`);
+    }
+    const { items, invalid } = parseRegistryItems(value);
+    const built = new Set(files.filter((f) => /(^|\/)public\/r\/[^/]+\.json$/.test(f)));
+    const inputs2 = items.filter(isCandidate).map((item) => {
+      const servedAt = [...built].find((f) => f.endsWith(`/r/${item.name}.json`));
+      return {
+        kind: item.type === "registry:block" ? "pattern" : "component",
+        name: item.name,
+        ...item.title ? { title: item.title } : {},
+        summary: item.description ?? "",
+        ref: `${registry}#${item.name}`,
+        url: blob(registry),
+        digest: item.itemSha256 ?? digestOf(item),
+        files: (item.files ?? []).map((f) => ({ path: f.path, sha256: f.sha256 ?? null })),
+        categories: item.categories ?? [],
+        ...servedAt ? { install: { command: `npx shadcn add ${raw(servedAt)}`, npm: [...new Set((item.dependencies ?? []).map(packageName))], registryDeps: [...new Set(item.registryDependencies ?? [])], implicitDeps: [] } } : {}
+      };
+    });
+    const others = items.filter((i) => !isCandidate(i));
+    return {
+      source,
+      license,
+      entries: itemsOf(source, license, fetchedAt, inputs2),
+      skipped: [...others.map((i) => ({ name: i.name, reason: `${i.type}: not a component or block` })), ...invalid > 0 ? [{ name: `${invalid} item${invalid === 1 ? "" : "s"}`, reason: "not valid registry items" }] : []],
+      notes: [`a shadcn registry: ${registry}`, ...notes]
+    };
+  }
+  const config = files.filter((f) => /(^|\/)youi\.config\.json$/.test(f)).sort(byDepth)[0];
+  if (config) {
+    const contracts = files.filter((f) => f.endsWith(".contract.json")).sort();
+    const inputs2 = [];
+    const skipped = [];
+    for (const path of contracts.slice(0, CONTRACTS_READ)) {
+      const text2 = await fetchText(client, raw(path), path).catch((error) => {
+        skipped.push({ name: path, reason: error instanceof Error ? error.message : String(error) });
+        return null;
+      });
+      if (!text2) continue;
+      try {
+        const contract = JSON.parse(text2.body);
+        if (typeof contract.name !== "string") throw new Error("no name");
+        inputs2.push({ kind: "component", name: contract.name, summary: typeof contract.summary === "string" ? contract.summary : "", ref: path, url: blob(path), digest: text2.sha256, files: [{ path, sha256: text2.sha256 }], categories: ["contract", ...typeof contract.status === "string" ? [contract.status] : []] });
+      } catch (error) {
+        skipped.push({ name: path, reason: `not a component contract: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }
+    return { source, license, entries: itemsOf(source, license, fetchedAt, inputs2), skipped, notes: [`a youiyoux design repo: ${config}`, ...notes, ...contracts.length > CONTRACTS_READ ? [`${contracts.length - CONTRACTS_READ} more contracts not read: at most ${CONTRACTS_READ}`] : []] };
+  }
+  const components = files.filter((f) => /(^|\/)components?\//.test(f) && COMPONENT_FILE.test(f) && !NOT_A_COMPONENT.test(f) && !f.includes("node_modules/")).sort();
+  if (components.length === 0) throw new IngestError(`${repo}${scope ? `/${scope}` : ""} has no registry.json, no youi.config.json and no components folder: nothing to read as Library items`);
+  const inputs = components.map((path) => ({ kind: "component", name: displayName(path), summary: cleanText(`${displayName(path)}, in ${path}`), ref: path, url: blob(path), digest: digestOf({ path, blob: blobs.get(path) }), categories: [] }));
+  return { source, license, entries: itemsOf(source, license, fetchedAt, inputs), skipped: [], notes: [`component files under a components folder, by name: their code was not read`, ...notes] };
+}
+
+// ../discover/src/ingest-storybook.ts
+var PATTERN = /^(pages?|templates?|layouts?|patterns?|screens?|examples?)$/i;
+var STORIES_LISTED = 6;
+async function readStorybook(target, client, fetchedAt) {
+  let index = null;
+  let entries = {};
+  for (const file of ["index.json", "stories.json"]) {
+    const url = `${target.base}/${file}`;
+    const got = await client.json(url, false);
+    if (!got.ok) continue;
+    const value = got.value;
+    const found = value.entries ?? value.stories;
+    if (found && typeof found === "object" && !Array.isArray(found)) {
+      entries = found;
+      index = { body: got.result.body, url, sha256: got.result.sha256 };
+      break;
+    }
+  }
+  if (!index) throw new IngestError(`${target.base} is not a GitHub repository, a Figma file or a DESIGN.md, and serves no Storybook index (index.json or stories.json): nothing to read`);
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const [key, raw] of Object.entries(entries)) {
+    const title2 = typeof raw.title === "string" ? raw.title : typeof raw.kind === "string" ? raw.kind : null;
+    const id = typeof raw.id === "string" ? raw.id : key;
+    if (!title2) continue;
+    const item = byTitle.get(title2) ?? { stories: [], first: null, docs: null };
+    if (raw.type === "docs") item.docs ??= id;
+    else {
+      item.first ??= id;
+      if (typeof raw.name === "string") item.stories.push(raw.name);
+    }
+    byTitle.set(title2, item);
+  }
+  const host = new URL(target.base).host;
+  const source = { kind: "storybook", name: host, url: target.base };
+  const inputs = [...byTitle].map(([title2, item]) => {
+    const parts = title2.split("/").map((p) => p.trim()).filter(Boolean);
+    const name = parts.at(-1) ?? title2;
+    const folders = parts.slice(0, -1);
+    const page = item.docs ? `?path=/docs/${item.docs}` : item.first ? `?path=/story/${item.first}` : "";
+    const stories = item.stories.length === 0 ? "docs only" : `${item.stories.length} ${item.stories.length === 1 ? "story" : "stories"}: ${item.stories.slice(0, STORIES_LISTED).join(", ")}${item.stories.length > STORIES_LISTED ? ", \u2026" : ""}`;
+    return {
+      kind: folders.some((f) => PATTERN.test(f)) ? "pattern" : "component",
+      name,
+      title: title2,
+      summary: `${title2} in ${host}'s Storybook, ${stories}`,
+      ref: title2,
+      url: `${target.base}/${page}`,
+      digest: index.sha256,
+      categories: folders
+    };
+  });
+  return {
+    source,
+    license: "unknown",
+    entries: itemsOf(source, "unknown", fetchedAt, inputs),
+    skipped: [],
+    notes: [`a Storybook: ${index.url}, ${byTitle.size} component title${byTitle.size === 1 ? "" : "s"}`, "licence unknown: a Storybook does not say one, so its items cannot be adopted until the code's licence is found"]
+  };
+}
+
+// ../discover/src/ingest.ts
+var INGEST_CAP = 300;
+var IngestError = class extends Error {
+};
+var GITHUB_SHORT = /^github:([\w.-]+)\/([\w.-]+?)(?:\.git)?(?:#([^\s]+))?$/;
+function classifyLink(link, options = {}) {
+  const text2 = link.trim();
+  const short = GITHUB_SHORT.exec(text2);
+  if (short) return { kind: "github", owner: short[1], repo: short[2], ref: short[3] ?? null, path: null };
+  let url = null;
+  try {
+    url = new URL(text2);
+  } catch {
+    url = null;
+  }
+  if (!url) {
+    if (/(^|\/)[^/]*\.md$/i.test(text2)) {
+      if (!options.allowLocal) throw new IngestError(`${text2} is a local file: only the CLI reads those (youiyoux library ingest ${text2})`);
+      return { kind: "design-md", location: resolve(text2), local: true };
+    }
+    throw new IngestError(`"${text2}" is not a link: give a GitHub repository (github:owner/repo or its https URL), a Storybook's https URL, a Figma file's URL, or a DESIGN.md (a path or an https URL)`);
+  }
+  if (url.protocol !== "https:") throw new IngestError(`${url.protocol}//${url.host} is not https: ingestion reads public https links only`);
+  const host = url.hostname.replace(/^www\./, "");
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (host === "github.com") {
+    if (parts.length < 2) throw new IngestError(`${text2} names no repository: expected https://github.com/<owner>/<repo>`);
+    const [owner, repo, kind, ref, ...rest] = parts;
+    if (kind === "blob" && ref && /\.md$/i.test(rest.at(-1) ?? "")) return { kind: "design-md", location: `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${rest.join("/")}`, local: false };
+    return { kind: "github", owner, repo: repo.replace(/\.git$/, ""), ref: kind === "tree" && ref ? ref : null, path: kind === "tree" && rest.length > 0 ? rest.join("/") : null };
+  }
+  if (host === "figma.com" || host.endsWith(".figma.com")) {
+    const at = parts.findIndex((p) => p === "design" || p === "file" || p === "proto");
+    const key = at >= 0 ? parts[at + 1] : void 0;
+    if (!key || !/^[A-Za-z0-9]{10,64}$/.test(key)) throw new IngestError(`${text2} names no Figma file: expected https://www.figma.com/design/<file key>/\u2026`);
+    return { kind: "figma", key };
+  }
+  if (/\.md$/i.test(url.pathname)) return { kind: "design-md", location: url.href, local: false };
+  const base = `${url.origin}${url.pathname.replace(/\/(?:index\.html|iframe\.html)?$/, "")}`.replace(/\/+$/, "");
+  return { kind: "storybook", base };
+}
+function itemsOf(source, license, fetchedAt, inputs) {
+  const used = /* @__PURE__ */ new Set();
+  const slug = sourceSlug(source.name.replace(/\//g, "-"));
+  return inputs.map((input) => {
+    const base = `lib:${slug}/${input.kind}/${nameSlug(input.name)}`;
+    let id = base;
+    for (let n = 2; used.has(id); n++) id = `${base}-${n}`;
+    used.add(id);
+    const draft = {
+      schema: "youi.library/v1",
+      id,
+      name: input.name,
+      ...input.title && input.title !== input.name ? { title: input.title } : {},
+      kind: input.kind,
+      stage: "library",
+      summary: summaryOf(input.summary, `${input.name} from ${source.name}`),
+      source: { name: source.name, ...input.url ? { url: input.url } : {}, ingestedAt: fetchedAt, kind: source.kind, ref: input.ref },
+      categories: [...new Set((input.categories ?? []).map((c) => c.toLowerCase()).filter(Boolean))],
+      swapsWith: [],
+      ...input.url ? { provenance: { fetchedAt, url: input.url, sha256: input.digest, files: [...input.files ?? []], registryHealth: null } } : {},
+      license,
+      ...input.install ? { install: input.install } : {}
+    };
+    const named = readNeed(input.name).concepts.length > 0 ? readNeed(input.name).concepts : readNeed(input.name.replace(/[^A-Za-z0-9]+/g, "").toLowerCase()).concepts;
+    const roles = input.kind === "token" ? [] : (named.length > 0 ? named : input.title ? readNeed(input.title).concepts : []).map((c) => c.id);
+    return LibraryEntry.parse({ ...draft, categories: [.../* @__PURE__ */ new Set([...roles, ...draft.categories])] });
+  });
+}
+function displayName(file) {
+  const stem = basename2(file).replace(/\.[^.]+$/, "");
+  return stem.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[-_\s]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+}
+var digestOf = (value) => sha256(typeof value === "string" ? value : JSON.stringify(value));
+async function fetchJson(client, url, what) {
+  const got = await client.json(url, false);
+  if (!got.ok) throw new IngestError(`could not read ${what} (${url}): ${got.status === 404 ? "not found" : got.message}`);
+  return got.value;
+}
+async function fetchText(client, url, what) {
+  const got = await client.get(url, "text/plain, text/markdown, */*");
+  if (!got.ok) throw new IngestError(`could not read ${what} (${url}): ${got.status === 404 ? "not found" : got.message}`);
+  return { body: got.body, sha256: got.sha256, fetchedAt: got.fetchedAt };
+}
+async function ingestLink(link, options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const target = classifyLink(link, options);
+  const fetchedAt = now().toISOString();
+  const result = await (target.kind === "github" ? readGithub(target, options.client, fetchedAt) : target.kind === "storybook" ? readStorybook(target, options.client, fetchedAt) : target.kind === "figma" ? options.figma ? readFigma(target, options.client, fetchedAt) : Promise.reject(new IngestError("a Figma file is read through Figma's API: set FIGMA_TOKEN to a personal access token that can read the file (Figma > Settings > Security > Personal access tokens)")) : readDesignMd(target, options.client, fetchedAt, (path) => readFile3(path, "utf8")));
+  const over = result.entries.length - INGEST_CAP;
+  return {
+    ...result,
+    link: link.trim(),
+    fetchedAt,
+    entries: result.entries.slice(0, INGEST_CAP),
+    notes: [...result.notes, ...over > 0 ? [`${over} more item${over === 1 ? "" : "s"} not read: at most ${INGEST_CAP} come from one link`] : []]
+  };
+}
+
 export {
   CONCEPTS,
   normalize,
@@ -1977,6 +2384,7 @@ export {
   implicitDeps,
   sourceSlug,
   nameSlug,
+  summaryOf,
   docsLinks,
   registryEntry,
   HEADLESS,
@@ -2072,5 +2480,14 @@ export {
   conceptOfName,
   conceptOfPackage,
   declaredPackages,
-  buildGaps
+  buildGaps,
+  INGEST_CAP,
+  IngestError,
+  classifyLink,
+  itemsOf,
+  displayName,
+  digestOf,
+  fetchJson,
+  fetchText,
+  ingestLink
 };

package/dist/chunks/ingest-OF4Z33L2.js

@@ -0,0 +1,52 @@
+import { createRequire as __youiRequire } from "node:module"; import { dirname as __youiDir } from "node:path"; import { fileURLToPath as __youiPath } from "node:url"; const require = __youiRequire(import.meta.url); const __youiDirname = __youiDir(__youiPath(import.meta.url));
+import {
+  padEnd,
+  plural,
+  style,
+  workflowStateDir
+} from "./chunk-FTF4MBV5.js";
+import "./chunk-HII2I2PI.js";
+import "./chunk-42YJX3W5.js";
+import "./chunk-HIXGUALJ.js";
+import "./chunk-S7UN5KQK.js";
+import "./chunk-WNTS7ZO4.js";
+
+// ../cli/src/ingest.ts
+import { userInfo } from "node:os";
+async function readLink(link, options) {
+  const { githubBuckets, ingestLink, PoliteClient } = await import("./src-7LETTRRF.js");
+  const env = options.env ?? process.env;
+  const token = env.GITHUB_TOKEN || void 0;
+  const figmaToken = env.FIGMA_TOKEN || void 0;
+  const client = new PoliteClient({ buckets: githubBuckets(token), ...token ? { token } : {}, ...figmaToken ? { figmaToken } : {} });
+  const result = await ingestLink(link, { client, allowLocal: options.allowLocal, figma: Boolean(figmaToken) });
+  return { link: result.link, source: result.source, license: result.license, fetchedAt: result.fetchedAt, entries: result.entries, skipped: result.skipped, notes: result.notes };
+}
+async function fileIngestDraft(project, reading, state) {
+  const { FileStore, RuleWorkflow } = await import("./src-CCGTRT5J.js");
+  const workflow = new RuleWorkflow({ projectRoot: project.root, store: new FileStore(workflowStateDir(project, state)), ...project.configFile ? { configPath: project.configFile } : {}, ...project.designOverride ? { designRoot: project.repo.root } : {}, ...project.rootOverride ? { productRoot: project.root } : {}, ingest: async () => reading });
+  const draft = await workflow.create({ kind: "person", name: userInfo().username }, { kind: "ingest", link: reading.link });
+  return { id: draft.id, problems: draft.problems };
+}
+function renderIngest(reading, filed) {
+  const licence = reading.license === "unknown" ? style.warn("licence unknown") : `licence ${reading.license.spdx}`;
+  const lines = [`${style.bold(reading.source.name)} ${style.dim(`\xB7 ${reading.source.kind}${reading.source.url ? ` \xB7 ${reading.source.url}` : ""}`)} \xB7 ${plural(reading.entries.length, "item")} \xB7 ${licence}`, ""];
+  const width = Math.min(28, Math.max(0, ...reading.entries.map((e) => e.name.length)));
+  for (const kind of ["component", "pattern", "token"]) {
+    const items = reading.entries.filter((e) => e.kind === kind);
+    if (items.length === 0) continue;
+    lines.push(style.bold(`${kind}s`));
+    for (const e of items) lines.push(`  ${padEnd(e.name.length > width ? `${e.name.slice(0, width - 1)}\u2026` : e.name, width)}  ${style.dim(e.categories.length ? e.categories.join(", ") : "no role")}  ${e.summary}`);
+    lines.push("");
+  }
+  const SKIPPED_SHOWN = 10;
+  if (reading.skipped.length > 0) lines.push(style.bold(`not read (${reading.skipped.length})`), ...reading.skipped.slice(0, SKIPPED_SHOWN).map((s) => `  ${s.name}  ${style.dim(s.reason)}`), ...reading.skipped.length > SKIPPED_SHOWN ? [style.dim(`  \u2026 ${reading.skipped.length - SKIPPED_SHOWN} more (--json lists them all)`)] : [], "");
+  lines.push(...reading.notes.map((n) => style.dim(`\xB7 ${n}`)), "");
+  lines.push(filed ? `${style.ok("filed")} as draft ${filed.id}: keep or drop each item, then approve, in youiyoux ui > Changes` : `Next: youiyoux library ingest ${reading.link} --draft files it for review (nothing is written to the Library until a person approves)`);
+  return lines.join("\n");
+}
+export {
+  fileIngestDraft,
+  readLink,
+  renderIngest
+};