@adia-ai/gen-ui 0.8.37

package/corpus/scripts/chunk-library.js

@@ -0,0 +1,335 @@
+/**
+ * Gen-UI training-chunk library.
+ *
+ * Loads the harvester's per-chunk JSON records + aggregate index from
+ * `packages/gen-ui/corpus/chunks/` into in-memory Maps for fast retrieval.
+ *
+ * Used by:
+ *   - packages/a2ui/mcp/server.js — exposes search_chunks / get_chunk / lookup_chunk tools
+ *   - packages/gen-ui/compose/strategies/zettel/chunk-synthesizer.js — Phase C.2
+ *
+ * Spec: .claude/docs/specs/genui-chunk-marker.md (Draft v0.1.0).
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CHUNKS_DIR = join(__dirname, '..', 'chunks');
+
+let _state = null;
+
+function load() {
+  if (_state) return _state;
+
+  const indexPath = join(CHUNKS_DIR, '_index.json');
+  if (!existsSync(indexPath)) {
+    _state = { index: null, chunks: new Map(), byPrimary: new Map(), byKind: new Map() };
+    return _state;
+  }
+
+  const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+  const chunks = new Map();      // name → record
+  const byPrimary = new Map();   // tagName → Set<name>
+  const byKind = new Map();      // kind → Set<name>
+
+  for (const file of readdirSync(CHUNKS_DIR)) {
+    // Underscore-prefixed files are harvester aux records (_index.json,
+    // _source-hashes.json), not chunks. The sibling loader
+    // (compose/strategies/_shared/chunk-loader.js) applies the same
+    // `rec.name` guard — a nameless record would poison the name→record Map.
+    if (file.startsWith('_') || !file.endsWith('.json')) continue;
+    const rec = JSON.parse(readFileSync(join(CHUNKS_DIR, file), 'utf8'));
+    const name = rec.name;
+    if (!name) continue;
+    chunks.set(name, rec);
+
+    const primary = rec.primary || rec.instances?.[0]?.primary || 'unknown';
+    if (!byPrimary.has(primary)) byPrimary.set(primary, new Set());
+    byPrimary.get(primary).add(name);
+
+    const kind = rec.kind || 'block';
+    if (!byKind.has(kind)) byKind.set(kind, new Set());
+    byKind.get(kind).add(name);
+  }
+
+  _state = { index, chunks, byPrimary, byKind };
+  return _state;
+}
+
+export function getChunk(name) {
+  const { chunks } = load();
+  return chunks.get(name) || null;
+}
+
+/**
+ * Inline `<!-- nested: other-chunk -->` placeholders with the referenced
+ * chunk's own HTML, recursively.
+ *
+ * The harvester splits a page into one chunk per `data-chunk` marker and
+ * leaves a comment where a nested marker was. 47 block chunks are such
+ * skeletons: `auth-signin-card-password` is a `card-ui` whose entire body is
+ * two placeholder comments, so handing it to a consumer verbatim renders an
+ * empty card. Resolving the references restores the markup the source page
+ * actually shipped.
+ *
+ * **Page-scoped.** A generic name like `auth-card-header` has 23 instances,
+ * one per page that used the marker; the record's first instance belongs to
+ * whichever page the harvester read first (the 404 page, as it happens).
+ * Only an instance harvested from the SAME page as the parent may be
+ * inlined — otherwise the sign-in card fills with 404 copy. With no
+ * same-page instance the placeholder comment stays.
+ *
+ * Cycle- and depth-guarded.
+ */
+export function resolveNestedChunks(html, { page, maxDepth = 4, seen = new Set() } = {}) {
+  if (!html || typeof html !== 'string' || maxDepth <= 0) return html || '';
+
+  const expand = (name) => {
+    if (seen.has(name)) return null;
+    const nested = getChunk(name);
+    if (!nested) return null;
+    const samePage = (nested.instances || []).find(
+      (i) => samePagePath(i.page, page) || samePagePath(i.source, page),
+    );
+    const nestedHtml = samePage?.html
+      || (samePagePath(nested.page, page) || samePagePath(nested.source, page) ? nested.html : null);
+    if (!nestedHtml) return null;
+    return resolveNestedChunks(nestedHtml, {
+      page,
+      maxDepth: maxDepth - 1,
+      seen: new Set([...seen, name]),
+    });
+  };
+
+  // The placeholder usually sits inside the very element the nested chunk is
+  // rooted at (`<header><!-- nested: auth-card-header --></header>`), so a
+  // naive splice would double the wrapper. Swap the whole element instead.
+  const withHosts = html.replace(
+    /<([a-z][a-z0-9-]*)\b[^>]*>\s*<!--\s*nested:\s*([a-z0-9-]+)\s*-->\s*<\/\1>/gi,
+    (match, hostTag, name) => {
+      const expanded = expand(name);
+      if (!expanded) return match;
+      const rootTag = expanded.match(/^\s*<([a-z][a-z0-9-]*)/i)?.[1];
+      return rootTag?.toLowerCase() === hostTag.toLowerCase() ? expanded : match;
+    },
+  );
+
+  return withHosts.replace(/<!--\s*nested:\s*([a-z0-9-]+)\s*-->/gi, (match, name) => expand(name) ?? match);
+}
+
+/** Compare harvest paths that differ only by a leading slash. */
+function samePagePath(a, b) {
+  if (!a || !b) return false;
+  return String(a).replace(/^\//, '') === String(b).replace(/^\//, '');
+}
+
+export function getAllChunks() {
+  const { chunks } = load();
+  return [...chunks.values()];
+}
+
+export function getChunkIndex() {
+  const { index } = load();
+  return index;
+}
+
+export function lookupChunksByPrimary(componentName) {
+  const { byPrimary, chunks } = load();
+  const names = byPrimary.get(componentName);
+  if (!names) return [];
+  return [...names].map((n) => chunks.get(n)).filter(Boolean);
+}
+
+export function listChunksByKind(kind) {
+  const { byKind, chunks } = load();
+  const names = byKind.get(kind);
+  if (!names) return [];
+  return [...names].map((n) => chunks.get(n)).filter(Boolean);
+}
+
+/**
+ * Generic UI words that must never be the evidence for a match: every
+ * corpus entry is a "form"/"page"/"component", so scoring them full weight
+ * ranks by vocabulary noise instead of by subject. Deliberate mirror of
+ * `compose/strategies/zettel/composition-library.js`'s `STOP_WORDS` — that
+ * module is browser-safe and must not import this node-only one, so the
+ * list is copied rather than shared. Change both or neither.
+ */
+export const SEARCH_STOP_WORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'but', 'of', 'to', 'in', 'on', 'at', 'for', 'with',
+  'form', 'forms', 'page', 'pages', 'view', 'views', 'screen', 'screens',
+  'ui', 'component', 'components', 'widget', 'widgets', 'block', 'blocks',
+  'section', 'sections', 'layout', 'layouts',
+]);
+
+/**
+ * Crude singularizer so a plural intent word reaches a singular chunk name:
+ * "notifications" → `settings-notification-channels-switches`. Applied to
+ * both sides of every comparison, so it can only join words that already
+ * differ by an "s" — never conflate two distinct concepts.
+ */
+function stem(word) {
+  if (word.length > 4 && word.endsWith('ies')) return `${word.slice(0, -3)}y`;
+  if (word.length > 3 && word.endsWith('s') && !word.endsWith('ss')) return word.slice(0, -1);
+  return word;
+}
+
+/**
+ * The component words a chunk is actually built from — `<table-ui>` → "table".
+ * "table of orders" must reach the chunks containing a table, not every chunk
+ * whose prose mentions orders. Mirrors the composition ranker's tag-token
+ * weight. Cached per record; the corpus is immutable once loaded.
+ */
+const tagWordCache = new WeakMap();
+function componentWords(rec) {
+  let words = tagWordCache.get(rec);
+  if (words) return words;
+  const html = rec.html || rec.instances?.[0]?.html || '';
+  words = new Set(
+    [...String(html).matchAll(/<([a-z][a-z0-9]*(?:-[a-z0-9]+)+)[\s>]/gi)]
+      .map((m) => stem(m[1].toLowerCase().replace(/-ui$/, '').replace(/-/g, ''))),
+  );
+  tagWordCache.set(rec, words);
+  return words;
+}
+
+/**
+ * Keyword scoring over chunk metadata. Used as the floor when embeddings
+ * are unavailable AND blended into the final score when they are.
+ */
+function keywordScore(name, rec, query) {
+  const q = query.toLowerCase();
+  // Split on everything that isn't alphanumeric: real intents carry
+  // punctuation ("split-pane editor: code on the left"), and a token of
+  // `editor:` matched no chunk name at all.
+  const tokens = q.split(/[^a-z0-9]+/).filter(Boolean);
+  // Hyphenated query compounds also match their closed form: "sign-in" →
+  // "signin", so the annotation keyword `signin` is reachable from the
+  // hyphenated intent wording (and vice versa).
+  for (const compound of q.match(/[a-z0-9]+(?:-[a-z0-9]+)+/g) || []) {
+    tokens.push(compound.replace(/-/g, ''));
+  }
+  // Harvested annotations (`data-chunk-keywords` / `data-chunk-description`)
+  // exist to make a chunk findable by the words a user actually types. They
+  // are whole-word matched only — substring matching here would let one long
+  // description outrank a name hit.
+  const annotationKeywords = new Set(
+    (rec.metadata?.keywords || []).map((k) => stem(String(k).toLowerCase())),
+  );
+  const descriptionWords = new Set(
+    String(rec.metadata?.description || '').toLowerCase()
+      .split(/[^a-z0-9]+/).filter(Boolean).map(stem),
+  );
+  const haystack = [
+    name,
+    rec.primary || '',
+    ...(rec.slots || []).map((s) => s.name || ''),
+    ...(rec.instances?.[0]?.slots || []).map((s) => s.name || ''),
+    Object.values(rec.attrs || {}).join(' '),
+  ].join(' ').toLowerCase();
+
+  const tagWords = componentWords(rec);
+
+  const nameWords = name.toLowerCase().split(/[-_]+/).map(stem);
+  let score = 0;
+  // Boost when the chunk's first word matches any query token (e.g. "dashboard" → dashboard-*).
+  // Stop-words are excluded: otherwise every `form-*` chunk out-ranks the actual
+  // form composition on the word "form" alone.
+  if (tokens.some((tok) => nameWords[0] === stem(tok) && !SEARCH_STOP_WORDS.has(tok))) score += 10;
+  if (haystack.includes(q)) score += 5;
+  const seen = new Set();
+  for (const raw of tokens) {
+    const tok = stem(raw);
+    if (seen.has(tok)) continue;                // a repeated query word scores once
+    seen.add(tok);
+    const isStop = SEARCH_STOP_WORDS.has(raw) || SEARCH_STOP_WORDS.has(tok);
+    if (nameWords.includes(tok)) score += isStop ? 1 : 3; // whole-word match (e.g. pane ≠ panel)
+    else if (name.toLowerCase().includes(tok)) score += 1; // substring fallback
+    if (haystack.includes(tok)) score += 1;
+    if (isStop) continue;
+    if (tagWords.has(tok)) score += 2;                    // built-from-this-component hit
+    if (annotationKeywords.has(tok)) score += 2;          // authored keyword hit
+    else if (descriptionWords.has(tok)) score += 1;       // authored description hit
+  }
+  return score;
+}
+
+/**
+ * Search chunks. Two-mode:
+ *   - Sync (default): keyword-only scoring; no API calls.
+ *   - Async (`searchChunksAsync`): blends semantic embedding cosine score
+ *     (when chunk-embeddings.json + an OPENAI/VOYAGE key are available)
+ *     with keyword score; falls back to keyword-only on any failure.
+ *
+ * The sync path is preserved for callers that need a synchronous result
+ * (e.g. compose_from_chunks's retrieval-first tier doesn't want to await
+ * a network round trip just to short-circuit on a strong keyword hit).
+ */
+export function searchChunks(query, { kind, limit = 20 } = {}) {
+  const { chunks } = load();
+  if (!query || typeof query !== 'string') return [];
+
+  const candidates = [];
+  for (const [name, rec] of chunks) {
+    if (kind && rec.kind !== kind) continue;
+    const score = keywordScore(name, rec, query);
+    if (score > 0) candidates.push({ name, score, kind: rec.kind, primary: rec.primary });
+  }
+  // Ties break by name, never by directory-read order: `readdir` is
+  // inode-ordered on Linux and alphabetical on macOS, so an arbitrary
+  // tie-break made the same query rank differently in CI than locally.
+  candidates.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  return candidates.slice(0, limit);
+}
+
+/**
+ * Embedding-blended search. Returns the top `limit` chunks ranked by
+ * (keyword + 5×cosine) when embeddings are available; falls back to
+ * keyword-only when not. Scoring weights are tuned so a perfect cosine
+ * match (1.0) contributes ~5 to the score, comparable to a name-prefix hit.
+ */
+export async function searchChunksAsync(query, { kind, limit = 20 } = {}) {
+  const { chunks } = load();
+  if (!query || typeof query !== 'string') return [];
+
+  let cosineByName = null;
+  // Env-var override: A2UI_DISABLE_EMBEDDINGS=1 forces keyword-only mode.
+  // Used by `npm run eval:diff -- --engine chunk-zettel-fast` and any
+  // diagnostic that needs to confirm the keyword path is independently
+  // healthy (i.e. retrieval works even when embeddings are stale or
+  // missing). Default: embeddings enabled when available.
+  const embeddingsDisabled = process.env.A2UI_DISABLE_EMBEDDINGS === '1';
+  if (!embeddingsDisabled) {
+    try {
+      const { scoreAll, available } = await import('../../retrieval/embedding/chunk-embedding-retriever.js');
+      if (await available()) {
+        cosineByName = await scoreAll(query);
+      }
+    } catch { /* embeddings unavailable — keyword-only */ }
+  }
+
+  const candidates = [];
+  for (const [name, rec] of chunks) {
+    if (kind && rec.kind !== kind) continue;
+    const kw = keywordScore(name, rec, query);
+    const cos = cosineByName?.get(name) || 0;
+    const blended = kw + cos * 5;
+    if (blended > 0) {
+      candidates.push({
+        name,
+        score: blended,
+        keywordScore: kw,
+        cosineScore: cos,
+        kind: rec.kind,
+        primary: rec.primary,
+      });
+    }
+  }
+  // Ties break by name, never by directory-read order: `readdir` is
+  // inode-ordered on Linux and alphabetical on macOS, so an arbitrary
+  // tie-break made the same query rank differently in CI than locally.
+  candidates.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  return candidates.slice(0, limit);
+}

package/node-shims.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Minimal ambient type shims for node: built-in modules.
+ * Required because tsconfig.base.json sets "types": [] which suppresses
+ * @types/node. Only the symbols actually used by the consuming projects
+ * are declared.
+ *
+ * Consumers: gen-ui/{compose,retrieval,validate} (via `../node-shims.d.ts`)
+ * and a2ui/mcp (via `../../gen-ui/node-shims.d.ts`). This lived at
+ * packages/a2ui/node-shims.d.ts until ADR-0048 P1 moved retrieval — its
+ * original and primary consumer — into @adia-ai/gen-ui. Kept as ONE copy
+ * on purpose: two ambient shim files drift silently.
+ *
+ * This file must NOT contain any import/export statements so it remains
+ * a script (ambient declaration file) rather than a module — only ambient
+ * module declarations placed in scripts work without TS2664.
+ */
+
+declare module 'node:fs/promises' {
+  function readFile(path: string, encoding: string): Promise<string>;
+  function writeFile(path: string, data: string): Promise<void>;
+  function mkdir(path: string, opts?: { recursive?: boolean }): Promise<string | undefined>;
+  function appendFile(path: string, data: string): Promise<void>;
+  function readdir(path: string): Promise<string[]>;
+}
+
+declare module 'node:path' {
+  const default_: {
+    dirname(p: string): string;
+    resolve(...paths: string[]): string;
+    join(...paths: string[]): string;
+    basename(p: string, ext?: string): string;
+    extname(p: string): string;
+  };
+  export default default_;
+  export function dirname(p: string): string;
+  export function resolve(...paths: string[]): string;
+  export function join(...paths: string[]): string;
+  export function basename(p: string, ext?: string): string;
+  export function extname(p: string): string;
+}
+
+declare module 'node:url' {
+  export function fileURLToPath(url: string): string;
+}
+
+declare module 'node:module' {
+  export function createRequire(filename: string): { resolve(id: string): string };
+}

package/package.json

@@ -0,0 +1,215 @@
+{
+  "name": "@adia-ai/gen-ui",
+  "version": "0.8.37",
+  "description": "AdiaUI generative-UI system — compose strategies, retrieval, the harvested training corpus, and catalog-aware + LLM-judge validation. Emits A2UI protocol messages; pairs with @adia-ai/a2ui (the protocol runtime). Folded from @adia-ai/a2ui-{compose,retrieval,corpus} + the catalog/semantic halves of the former @adia-ai/a2ui-validator (ADR-0048).",
+  "type": "module",
+  "main": "./compose/index.js",
+  "exports": {
+    ".": {
+      "types": "./compose/index.d.ts",
+      "import": "./compose/index.js",
+      "default": "./compose/index.js"
+    },
+    "./compose": {
+      "types": "./compose/index.d.ts",
+      "import": "./compose/index.js",
+      "default": "./compose/index.js"
+    },
+    "./compose/core": {
+      "types": "./compose/core/generator.d.ts",
+      "import": "./compose/core/generator.js",
+      "default": "./compose/core/generator.js"
+    },
+    "./compose/strategies/zettel": {
+      "types": "./compose/strategies/zettel/generator-adapter.d.ts",
+      "import": "./compose/strategies/zettel/generator-adapter.js",
+      "default": "./compose/strategies/zettel/generator-adapter.js"
+    },
+    "./compose/strategies/registry": {
+      "types": "./compose/strategies/registry.d.ts",
+      "import": "./compose/strategies/registry.js",
+      "default": "./compose/strategies/registry.js"
+    },
+    "./compose/strategies/cascade": {
+      "types": "./compose/strategies/cascade.d.ts",
+      "import": "./compose/strategies/cascade.js",
+      "default": "./compose/strategies/cascade.js"
+    },
+    "./compose/strategies/escalation": {
+      "types": "./compose/strategies/escalation.d.ts",
+      "import": "./compose/strategies/escalation.js",
+      "default": "./compose/strategies/escalation.js"
+    },
+    "./compose/transpiler": {
+      "types": "./compose/transpiler/transpiler.d.ts",
+      "import": "./compose/transpiler/transpiler.js",
+      "default": "./compose/transpiler/transpiler.js"
+    },
+    "./compose/evals": {
+      "types": "./compose/evals/harness.d.ts",
+      "import": "./compose/evals/harness.mjs",
+      "default": "./compose/evals/harness.mjs"
+    },
+    "./compose/core/*": {
+      "types": "./compose/core/*.d.ts",
+      "import": "./compose/core/*.js",
+      "default": "./compose/core/*.js"
+    },
+    "./compose/strategies/*": {
+      "types": "./compose/strategies/*.d.ts",
+      "import": "./compose/strategies/*.js",
+      "default": "./compose/strategies/*.js"
+    },
+    "./compose/shared/*": {
+      "types": "./compose/shared/*.d.ts",
+      "import": "./compose/shared/*.js",
+      "default": "./compose/shared/*.js"
+    },
+    "./compose/transpiler/*": {
+      "types": "./compose/transpiler/*.d.ts",
+      "import": "./compose/transpiler/*.js",
+      "default": "./compose/transpiler/*.js"
+    },
+    "./retrieval": {
+      "types": "./retrieval/index.d.ts",
+      "import": "./retrieval/index.js",
+      "default": "./retrieval/index.js"
+    },
+    "./retrieval/intent": {
+      "types": "./retrieval/intent/index.d.ts",
+      "import": "./retrieval/intent/index.js",
+      "default": "./retrieval/intent/index.js"
+    },
+    "./retrieval/intent/*": {
+      "types": "./retrieval/intent/*.d.ts",
+      "import": "./retrieval/intent/*.js",
+      "default": "./retrieval/intent/*.js"
+    },
+    "./retrieval/embedding": {
+      "types": "./retrieval/embedding/index.d.ts",
+      "import": "./retrieval/embedding/index.js",
+      "default": "./retrieval/embedding/index.js"
+    },
+    "./retrieval/embedding/*": {
+      "types": "./retrieval/embedding/*.d.ts",
+      "import": "./retrieval/embedding/*.js",
+      "default": "./retrieval/embedding/*.js"
+    },
+    "./retrieval/feedback": {
+      "types": "./retrieval/feedback/index.d.ts",
+      "import": "./retrieval/feedback/index.js",
+      "default": "./retrieval/feedback/index.js"
+    },
+    "./retrieval/feedback/*": {
+      "types": "./retrieval/feedback/*.d.ts",
+      "import": "./retrieval/feedback/*.js",
+      "default": "./retrieval/feedback/*.js"
+    },
+    "./retrieval/authoring": {
+      "types": "./retrieval/authoring/index.d.ts",
+      "import": "./retrieval/authoring/index.js",
+      "default": "./retrieval/authoring/index.js"
+    },
+    "./retrieval/authoring/*": {
+      "types": "./retrieval/authoring/*.d.ts",
+      "import": "./retrieval/authoring/*.js",
+      "default": "./retrieval/authoring/*.js"
+    },
+    "./retrieval/*": {
+      "types": "./retrieval/*.d.ts",
+      "import": "./retrieval/*.js",
+      "default": "./retrieval/*.js"
+    },
+    "./corpus": {
+      "types": "./corpus/catalog-a2ui_0_9.d.ts",
+      "import": "./corpus/catalog-a2ui_0_9.json",
+      "default": "./corpus/catalog-a2ui_0_9.json"
+    },
+    "./corpus/manifest": {
+      "types": "./corpus/manifest.d.ts",
+      "import": "./corpus/manifest.json",
+      "default": "./corpus/manifest.json"
+    },
+    "./corpus/chunks": {
+      "types": "./corpus/chunks/_index.d.ts",
+      "import": "./corpus/chunks/_index.json",
+      "default": "./corpus/chunks/_index.json"
+    },
+    "./corpus/chunks/*": {
+      "types": "./corpus/chunks/*.d.ts",
+      "import": "./corpus/chunks/*",
+      "default": "./corpus/chunks/*"
+    },
+    "./corpus/chunk-library": {
+      "types": "./corpus/scripts/chunk-library.d.ts",
+      "import": "./corpus/scripts/chunk-library.js",
+      "default": "./corpus/scripts/chunk-library.js"
+    },
+    "./corpus/chunk-embeddings": {
+      "types": "./corpus/chunk-embeddings.d.ts",
+      "import": "./corpus/chunk-embeddings.json",
+      "default": "./corpus/chunk-embeddings.json"
+    },
+    "./validate/catalog": {
+      "types": "./validate/catalog-validator.d.ts",
+      "import": "./validate/catalog-validator.js",
+      "default": "./validate/catalog-validator.js"
+    },
+    "./validate/semantic": {
+      "types": "./validate/semantic/index.d.ts",
+      "import": "./validate/semantic/index.js",
+      "default": "./validate/semantic/index.js"
+    },
+    "./validate/semantic/*": {
+      "types": "./validate/semantic/*.d.ts",
+      "import": "./validate/semantic/*.js",
+      "default": "./validate/semantic/*.js"
+    }
+  },
+  "files": [
+    "compose/core/",
+    "compose/strategies/",
+    "compose/shared/",
+    "compose/evals/",
+    "compose/transpiler/",
+    "compose/index.js",
+    "retrieval/*.js",
+    "retrieval/intent/",
+    "retrieval/embedding/",
+    "retrieval/feedback/",
+    "retrieval/authoring/",
+    "corpus/catalog-a2ui_0_9.json",
+    "corpus/catalog-a2ui_0_9_rules.txt",
+    "corpus/manifest.json",
+    "corpus/chunks/",
+    "corpus/chunk-embeddings.json",
+    "corpus/scripts/chunk-library.js",
+    "validate/catalog-validator.js",
+    "validate/semantic/",
+    "README.md",
+    "CHANGELOG.md",
+    "!**/*.ts",
+    "**/*.d.ts",
+    "!**/*.test.js"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adiahealth/gen-ui-kit.git",
+    "directory": "packages/gen-ui"
+  },
+  "dependencies": {
+    "@adia-ai/agent": "^0.8.0",
+    "@adia-ai/a2ui": "^0.8.0",
+    "@adia-ai/llm": "^0.8.0",
+    "ajv": "^8.0.0",
+    "ajv-formats": "^3.0.0"
+  },
+  "devDependencies": {
+    "@genui/producer": "*"
+  }
+}