@adia-ai/a2ui-retrieval 0.6.4 → 0.6.7

package/intent/intent-gate.js

@@ -1,18 +1,5 @@
-/**
- * Intent Gate — Detect whether a user message is conversational (question,
- * greeting, meta-question) vs. a UI generation request.
- *
- * Used by the chat setup to route non-generation messages to a text reply
- * instead of the full 6-stage pipeline.
- */
-
-/** Question starters that signal conversational intent */
 const QUESTION_STARTERS = /^\s*(what|how|why|can you|could you|tell me|explain|describe|help|who|where|when|is there|are there|do you|does|did|will|should|would|which|list|show me how)\b/i;
-
-/** Greetings and social signals */
 const GREETINGS = /^\s*(hi|hey|hello|thanks|thank you|bye|goodbye|ok|okay|sure|great|nice|cool|awesome|good|perfect)\b/i;
-
-/** Explicit meta-questions about the system itself */
 const META_PATTERNS = [
   /what\s+(components?|types?|elements?)\s+(are|do|can)/i,
   /available\s+(components?|types?|elements?)/i,
@@ -25,131 +12,85 @@ const META_PATTERNS = [
   /explain\s+(the|how|what|a)/i,
   /how\s+(to|do\s+I)\s+(use|create|build|make)/i,
   /what\s+would\s+.+\s+look\s+like/i,
-  /show\s+me\s+how/i,
+  /show\s+me\s+how/i
 ];
-
-/** Content that is clearly not a UI intent (injection, noise, gibberish) */
 const NOISE_PATTERNS = [
-  /^<[^>]+>/,              // Starts with HTML tag
-  /^\s*[^\w\s]{3,}/,      // Starts with 3+ non-word chars
+  /^<[^>]+>/,
+  // Starts with HTML tag
+  /^\s*[^\w\s]{3,}/
+  // Starts with 3+ non-word chars
 ];
-
-/** Vague, motivational, or abstract phrases with no UI-describing language.
- *  These are common conversational inputs that the LLM hallucinates UIs from. */
 const VAGUE_PATTERNS = [
-  /^(do|just|go|let'?s|get|keep|stay|stop|try|move|make it|finish|start|begin|end|run)\b.{0,30}$/i,  // short imperative without UI nouns
+  /^(do|just|go|let'?s|get|keep|stay|stop|try|move|make it|finish|start|begin|end|run)\b.{0,30}$/i,
+  // short imperative without UI nouns
   /\b(you gotta|gotta do|no excuses|believe|motivat|inspir|goal|dream|life|love|hate|feel|think about)\b/i,
-  /\b(what is preventing|what stops|why can't|why won't)\b/i,  // philosophical/motivational questions
-  /\b(do it|get it done|let'?s go|make it happen|just do it|never give up)\b/i,  // motivational slogans
+  /\b(what is preventing|what stops|why can't|why won't)\b/i,
+  // philosophical/motivational questions
+  /\b(do it|get it done|let'?s go|make it happen|just do it|never give up)\b/i
+  // motivational slogans
 ];
-
-/** Tool-use and action-oriented intents that should be handled conversationally,
- *  not as UI generation requests. These are commands directed at the system. */
 const TOOL_USE_PATTERNS = [
   /\b(create|file|write|open|submit|log)\s+(a\s+)?(ticket|bug|issue|report|feature request)/i,
   /\b(report|flag)\s+(a\s+)?(bug|issue|problem|error|regression)/i,
-  /\b(why|how come)\s+(does|did|is|was|are)\b/i,   // "why does X do Y" — asking for rationale
+  /\b(why|how come)\s+(does|did|is|was|are)\b/i,
+  // "why does X do Y" — asking for rationale
   /\bthis\s+(is|looks?)\s+(broken|wrong|buggy|off|weird|strange)/i,
   /\b(fix|repair|debug|investigate)\s+(this|the|that)/i,
   /\bsomething\s+(is|seems|looks?)\s+(wrong|broken|off)/i,
   /\bmark\s+(this|it)\s+as\b/i,
-  /\b(save|bookmark|pin)\s+(this|the)\s+(pattern|output|result)/i,
+  /\b(save|bookmark|pin)\s+(this|the)\s+(pattern|output|result)/i
 ];
-
-/**
- * Determine if a user message is conversational (should get a text reply)
- * or a UI generation request (should go through the pipeline).
- *
- * @param {string} text — Raw user input
- * @param {{ confidence: number, matchedSignals: string[] }} classifyResult — From classifyIntent()
- * @returns {{ conversational: boolean, reason: string }}
- */
-export function isConversational(text, classifyResult) {
-  const trimmed = (text ?? '').trim();
-  if (!classifyResult || typeof classifyResult !== 'object') {
-    classifyResult = { confidence: 0, matchedSignals: [] };
+function isConversational(text, classifyResult) {
+  const trimmed = (text ?? "").trim();
+  let cls = classifyResult && typeof classifyResult === "object" ? classifyResult : { confidence: 0, matchedSignals: [] };
+  if (trimmed.length < 5 && cls.confidence === 0) {
+    return { conversational: true, reason: "short-input" };
   }
-
-  // Very short messages without generation keywords are likely conversational
-  if (trimmed.length < 5 && classifyResult.confidence === 0) {
-    return { conversational: true, reason: 'short-input' };
-  }
-
-  // Noise/injection detection — not a real intent
   for (const pattern of NOISE_PATTERNS) {
-    if (pattern.test(trimmed) && classifyResult.confidence === 0) {
-      return { conversational: true, reason: 'noise-input' };
+    if (pattern.test(trimmed) && cls.confidence === 0) {
+      return { conversational: true, reason: "noise-input" };
     }
   }
-
-  // Explicit meta-questions about the system → always conversational
   for (const pattern of META_PATTERNS) {
     if (pattern.test(trimmed)) {
-      return { conversational: true, reason: 'meta-question' };
+      return { conversational: true, reason: "meta-question" };
     }
   }
-
-  // Tool-use commands (create ticket, report bug, etc.) → conversational
   for (const pattern of TOOL_USE_PATTERNS) {
     if (pattern.test(trimmed)) {
-      return { conversational: true, reason: 'tool-use' };
+      return { conversational: true, reason: "tool-use" };
     }
   }
-
-  // Vague / motivational / abstract input with no or weak domain signals
-  // Catches "do what you gotta do", "just do it", "what is preventing you?", etc.
-  // These have zero genuine UI intent but the LLM hallucinates full UIs from them.
-  if (classifyResult.confidence < 0.2) {
+  if (cls.confidence < 0.2) {
     for (const pattern of VAGUE_PATTERNS) {
       if (pattern.test(trimmed)) {
-        return { conversational: true, reason: 'vague-or-abstract' };
+        return { conversational: true, reason: "vague-or-abstract" };
       }
     }
   }
-
-  // Greetings with no generation signals
-  if (GREETINGS.test(trimmed) && classifyResult.confidence === 0) {
-    return { conversational: true, reason: 'greeting' };
+  if (GREETINGS.test(trimmed) && cls.confidence === 0) {
+    return { conversational: true, reason: "greeting" };
   }
-
-  // High confidence in a domain → generation request
-  if (classifyResult.confidence >= 0.3) {
-    return { conversational: false, reason: 'high-domain-confidence' };
+  if (cls.confidence >= 0.3) {
+    return { conversational: false, reason: "high-domain-confidence" };
   }
-
-  // Has matched at least 2 domain signals → generation
-  if (classifyResult.matchedSignals?.length >= 2) {
-    return { conversational: false, reason: 'multiple-domain-signals' };
+  if ((cls.matchedSignals?.length ?? 0) >= 2) {
+    return { conversational: false, reason: "multiple-domain-signals" };
   }
-
-  // Question pattern with single low-confidence signal → conversational
-  // Key insight: "explain the card content model" has 1 signal ("card") but
-  // the leading "explain" means the user wants information, not generation.
-  if (QUESTION_STARTERS.test(trimmed) && classifyResult.matchedSignals?.length <= 1) {
-    return { conversational: true, reason: 'question-single-signal' };
+  if (QUESTION_STARTERS.test(trimmed) && (cls.matchedSignals?.length ?? 0) <= 1) {
+    return { conversational: true, reason: "question-single-signal" };
   }
-
-  // Greetings even with some confidence → still conversational
-  if (GREETINGS.test(trimmed) && classifyResult.confidence < 0.2) {
-    return { conversational: true, reason: 'greeting-low-confidence' };
+  if (GREETINGS.test(trimmed) && cls.confidence < 0.2) {
+    return { conversational: true, reason: "greeting-low-confidence" };
   }
-
-  // Default: if there's any domain signal at all, treat as generation
-  if (classifyResult.confidence > 0) {
-    return { conversational: false, reason: 'has-domain-signal' };
+  if (cls.confidence > 0) {
+    return { conversational: false, reason: "has-domain-signal" };
   }
-
-  // No signals — check for question marks or question patterns
-  if (trimmed.endsWith('?')) {
-    return { conversational: true, reason: 'ends-with-question-mark' };
+  if (trimmed.endsWith("?")) {
+    return { conversational: true, reason: "ends-with-question-mark" };
   }
-
-  // No domain signals at all — this input doesn't describe UI.
-  // Phrases like "do what you gotta do", "what is preventing you?", or
-  // motivational text have zero keyword overlap with any UI domain.
-  // Route to conversational so the system can ask for clarification
-  // instead of hallucinating a UI from abstract text.
-  // Legitimate UI intents like "sidebar with navigation" will have
-  // domain signals (sidebar → layout/navigation) and be caught above.
-  return { conversational: true, reason: 'no-ui-signals' };
+  return { conversational: true, reason: "no-ui-signals" };
 }
+export {
+  isConversational
+};

package/intent/prompt-analyzer.js

@@ -1,91 +1,47 @@
-/**
- * Prompt Analyzer — baseline ingestion stage for the gen-ui pipeline.
- *
- * Every user intent enters through here, regardless of engine (monolithic,
- * zettel) or mode (instant, pro, thinking). The analyzer extracts structured
- * signals from the raw prompt — what concepts the user is gesturing at, which
- * AdiaUI components are implied, what implicit requirements a good designer
- * would add — and produces a "steelmanned" enriched brief that downstream
- * stages reason against.
- *
- * Output schema:
- *   {
- *     raw:               string  // user's original intent, verbatim
- *     concepts:          string[] // 2-5 short concept tags ("commerce", "auth", "data-display")
- *     entities:          string[] // explicit nouns from the prompt ("image", "title", "price")
- *     impliedComponents: string[] // 4-12 AdiaUI component names ("Card", "Image", "Button")
- *     styleHints:        string[] // visual/style hints ("3D", "minimal", "dense"), [] if none
- *     steelman:          string   // 1-2 sentence enriched brief
- *     analyzed:          boolean  // true if LLM call succeeded; false if fell back to passthrough
- *   }
- *
- * Failure mode: if the LLM call throws or returns unparseable JSON, we
- * gracefully degrade to a passthrough analysis (steelman = raw intent, no
- * extracted signals). Generation continues; quality may suffer but nothing
- * breaks. See diagnosis report 2026-04-19 for why silent failure is the right
- * default here (vs. raising) — the analyzer is enrichment, not a gate.
- *
- * Latency budget: one Haiku call, typically 800-1500ms. This is the new floor
- * for every generation regardless of mode.
- */
-
-// Component vocabulary derived from the catalog. Two artifacts:
-//   - displayList: human-readable list shown to the LLM, with aliases inlined
-//     ("Swiper (also: Carousel, Slideshow)") so the LLM knows it can use any.
-//   - allowedSet:  canonical AND alias names accepted in impliedComponents,
-//     because the runtime registry already maps aliases to the right tag.
-// Loaded once at module init from the catalog. Changes require server restart.
 let _vocab = null;
 async function getVocab() {
   if (_vocab) return _vocab;
   let catalogJson = {};
   try {
-    const IS_NODE = typeof process !== 'undefined' && process.versions?.node;
+    const IS_NODE = typeof process !== "undefined" && process.versions?.node;
     if (IS_NODE) {
-      const fs = await import(/* @vite-ignore */ 'node:fs/promises');
-      const path = await import(/* @vite-ignore */ 'node:path');
-      const url = await import(/* @vite-ignore */ 'node:url');
-      // Since §65 (v0.4.7), reads from canonical v0.9 catalog at
-      // corpus/catalog-a2ui_0_9.json (assembled from yamls). Previously read
-      // the hand-maintained corpus/patterns/_components.json retired in §65.
-      // packages/a2ui/retrieval/intent → up 2 → packages/a2ui → corpus/catalog-a2ui_0_9.json
+      const fs = await import(
+        /* @vite-ignore */
+        "node:fs/promises"
+      );
+      const path = await import(
+        /* @vite-ignore */
+        "node:path"
+      );
+      const url = await import(
+        /* @vite-ignore */
+        "node:url"
+      );
       const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-      const raw = await fs.readFile(path.join(__dirname, '../../corpus/catalog-a2ui_0_9.json'), 'utf8');
+      const raw = await fs.readFile(path.join(__dirname, "../../corpus/catalog-a2ui_0_9.json"), "utf8");
       catalogJson = JSON.parse(raw);
     } else {
-      const resp = await fetch(new URL('../../corpus/catalog-a2ui_0_9.json', import.meta.url));
+      const resp = await fetch(new URL("../../corpus/catalog-a2ui_0_9.json", import.meta.url));
       if (resp.ok) catalogJson = await resp.json();
     }
-  } catch { /* empty vocab — analyzer will still work, just unconstrained */ }
-
-  // Adapt v0.9 catalog shape: `components: {Name: {x-adiaui: {synonyms: {tags: [...]}}}}`
-  // → legacy `{Name: {aliases}}` shape this vocab builder expects.
-  const comps = catalogJson?.components || {};
+  } catch {
+  }
+  const comps = catalogJson?.["components"] ?? {};
   const displayList = [];
-  const allowedSet = new Set();
+  const allowedSet = /* @__PURE__ */ new Set();
   for (const [name, def] of Object.entries(comps)) {
     allowedSet.add(name);
-    const ext = def?.['x-adiaui'] || {};
-    const syns = (ext.synonyms && typeof ext.synonyms === 'object') ? ext.synonyms : null;
-    const aliases = Array.isArray(syns?.tags) ? syns.tags : [];
+    const ext = def?.["x-adiaui"] ?? {};
+    const syns = ext && typeof ext === "object" ? ext["synonyms"] : null;
+    const tags = syns && typeof syns === "object" ? syns["tags"] : null;
+    const aliases = Array.isArray(tags) ? tags.filter((t) => typeof t === "string") : [];
     for (const a of aliases) allowedSet.add(a);
-    displayList.push(aliases.length ? `${name} (also: ${aliases.join(', ')})` : name);
+    displayList.push(aliases.length ? `${name} (also: ${aliases.join(", ")})` : name);
   }
   _vocab = { displayList, allowedSet };
   return _vocab;
 }
-
-/**
- * Analyze a user prompt — extract concepts, entities, implied components,
- * style hints, and produce a steelmanned brief.
- *
- * @param {object} opts
- * @param {string} opts.intent — Raw user intent
- * @param {object} [opts.llmAdapter] — LLM adapter (must implement .complete())
- * @param {object} [opts.domain] — Domain classification from domain-router (optional context)
- * @returns {Promise<object>} Analysis object (see module docstring for schema)
- */
-export async function analyzePrompt({ intent, llmAdapter, domain }) {
+async function analyzePrompt({ intent, llmAdapter, domain }) {
   const passthrough = {
     raw: intent,
     concepts: [],
@@ -93,23 +49,16 @@ export async function analyzePrompt({ intent, llmAdapter, domain }) {
     impliedComponents: [],
     styleHints: [],
     steelman: intent,
-    analyzed: false,
+    analyzed: false
   };
-
   if (!intent || !llmAdapter) return passthrough;
-
   const { displayList, allowedSet } = await getVocab();
-  const componentList = displayList.length
-    ? displayList.join(', ')
-    : 'Card, Section, Header, Footer, Column, Row, Grid, Button, Input, Text, Image, Badge, Icon, Avatar, Alert, Modal, Tabs, Accordion';
-
-  const domainHint = domain?.domain && domain.confidence > 0
-    ? `\nDomain classifier suggests: ${domain.domain} (confidence ${domain.confidence})`
-    : '';
-
+  const componentList = displayList.length ? displayList.join(", ") : "Card, Section, Header, Footer, Column, Row, Grid, Button, Input, Text, Image, Badge, Icon, Avatar, Alert, Modal, Tabs, Accordion";
+  const domainHint = domain?.["domain"] && (domain?.["confidence"] ?? 0) > 0 ? `
+Domain classifier suggests: ${domain["domain"]} (confidence ${domain["confidence"]})` : "";
   const systemPrompt = `You are a UI brief enricher for the AdiaUI design system. Given a terse or under-specified user prompt, you extract structured signals and produce an enriched brief that a downstream UI generator can use to produce a polished, complete UI.
 
-Your output is JSON with this exact shape — no markdown, no explanation:
+Your output is JSON with this exact shape \u2014 no markdown, no explanation:
 {
   "concepts": [string],          // 2-5 short concept tags (e.g. "commerce", "authentication", "data-display", "navigation")
   "entities": [string],          // explicit nouns from the prompt (lowercase, singular)
@@ -121,7 +70,7 @@ Your output is JSON with this exact shape — no markdown, no explanation:
 AdiaUI components you may name in implied_components (use these names exactly): ${componentList}
 
 Rules:
-- Extract entities verbatim from the prompt — do not invent.
+- Extract entities verbatim from the prompt \u2014 do not invent.
 - implied_components should include both the obvious (Card, Button) AND the ones a thoughtful designer would add (Badge for sale tag on a product, Avatar for a user row, EmptyState for empty data).
 - The steelman expands the prompt into what the user MEANT, not what they SAID. Add the implicit requirements: typical sub-elements, sensible defaults, a header, a footer, common variants. Do NOT add scope the user wouldn't want (e.g. don't turn "login form" into "login form with social auth" unless that's a near-universal expectation).
 - Keep steelman under 250 characters.
@@ -135,86 +84,79 @@ Input: "settings page with toggles for notifications, dark mode, and privacy"
 Output: {"concepts":["settings","preferences"],"entities":["notifications","dark mode","privacy","toggles"],"implied_components":["Card","Header","Section","Toggle","Text","Divider"],"style_hints":[],"steelman":"Settings page with three toggle rows for notifications, dark mode, and privacy. Each row has a label, description, and toggle. Grouped under a header card."}
 
 Input: "make it 3D"
-Output: {"concepts":["style-modifier"],"entities":[],"implied_components":[],"style_hints":["3D","depth","shadow"],"steelman":"Modify the existing canvas to feel three-dimensional — add elevation, layered shadows, and depth-suggesting transforms. Apply to existing components without changing structure."}`;
-
+Output: {"concepts":["style-modifier"],"entities":[],"implied_components":[],"style_hints":["3D","depth","shadow"],"steelman":"Modify the existing canvas to feel three-dimensional \u2014 add elevation, layered shadows, and depth-suggesting transforms. Apply to existing components without changing structure."}`;
   const userMsg = `Prompt: "${intent}"${domainHint}`;
-
   let response;
   try {
     response = await llmAdapter.complete({
-      messages: [{ role: 'user', content: userMsg }],
-      systemPrompt,
+      messages: [{ role: "user", content: userMsg }],
+      systemPrompt
     });
   } catch {
     return passthrough;
   }
-
   const text = response?.content;
   if (!text) return passthrough;
-
-  // Truncation: if the analyzer LLM hit max_tokens we'd rather use the raw
-  // prompt than a half-parsed analysis that misleads downstream stages.
-  if (response.stopReason && response.stopReason !== 'end' && response.stopReason !== 'end_turn' && response.stopReason !== 'stop') {
+  if (response.stopReason && response.stopReason !== "end" && response.stopReason !== "end_turn" && response.stopReason !== "stop") {
     return passthrough;
   }
-
-  // Try direct parse, then code-fence extraction, then outermost JSON.
   let parsed = null;
-  try { parsed = JSON.parse(text.trim()); } catch { /* fall through */ }
+  try {
+    parsed = JSON.parse(text.trim());
+  } catch {
+  }
   if (!parsed) {
     const fence = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-    if (fence) try { parsed = JSON.parse(fence[1].trim()); } catch { /* fall through */ }
+    if (fence) try {
+      parsed = JSON.parse((fence[1] ?? "").trim());
+    } catch {
+    }
   }
   if (!parsed) {
-    const start = text.indexOf('{');
-    const end = text.lastIndexOf('}');
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
     if (start >= 0 && end > start) {
-      try { parsed = JSON.parse(text.slice(start, end + 1)); } catch { /* fall through */ }
+      try {
+        parsed = JSON.parse(text.slice(start, end + 1));
+      } catch {
+      }
     }
   }
-  if (!parsed || typeof parsed !== 'object') return passthrough;
-
-  // Constrain impliedComponents to the allowed vocab (canonical names AND
-  // their aliases — runtime registry maps aliases to the right tag, and the
-  // LLM was told it can use either, so both are accepted here).
-  const impliedComponents = Array.isArray(parsed.implied_components)
-    ? parsed.implied_components.filter(c => typeof c === 'string' && (allowedSet.size === 0 || allowedSet.has(c)))
-    : [];
-
+  if (!parsed || typeof parsed !== "object") return passthrough;
+  const p = parsed;
+  const impliedComponents = Array.isArray(p["implied_components"]) ? p["implied_components"].filter((c) => typeof c === "string" && (allowedSet.size === 0 || allowedSet.has(c))) : [];
   return {
     raw: intent,
-    concepts:          asStringArray(parsed.concepts).slice(0, 8),
-    entities:          asStringArray(parsed.entities).slice(0, 16),
+    concepts: asStringArray(p["concepts"]).slice(0, 8),
+    entities: asStringArray(p["entities"]).slice(0, 16),
     impliedComponents: impliedComponents.slice(0, 16),
-    styleHints:        asStringArray(parsed.style_hints).slice(0, 8),
-    steelman:          (typeof parsed.steelman === 'string' && parsed.steelman.trim()) || intent,
-    analyzed:          true,
+    styleHints: asStringArray(p["style_hints"]).slice(0, 8),
+    steelman: typeof p["steelman"] === "string" && p["steelman"].trim() || intent,
+    analyzed: true
   };
 }
-
 function asStringArray(v) {
   if (!Array.isArray(v)) return [];
-  return v.filter(x => typeof x === 'string' && x.trim().length > 0).map(x => x.trim());
+  return v.filter((x) => typeof x === "string" && x.trim().length > 0).map((x) => x.trim());
 }
-
-/**
- * Format an analysis object for inclusion in a downstream system prompt.
- * Keeps the shape compact so it doesn't blow the context budget.
- */
-export function formatAnalysisForPrompt(analysis) {
-  if (!analysis || !analysis.analyzed) return '';
+function formatAnalysisForPrompt(analysis) {
+  if (!analysis || !analysis.analyzed) return "";
   const parts = [];
   if (analysis.steelman && analysis.steelman !== analysis.raw) {
     parts.push(`ENRICHED BRIEF: ${analysis.steelman}`);
   }
   if (analysis.impliedComponents?.length) {
-    parts.push(`EXPECTED COMPONENTS: ${analysis.impliedComponents.join(', ')}`);
+    parts.push(`EXPECTED COMPONENTS: ${analysis.impliedComponents.join(", ")}`);
   }
   if (analysis.concepts?.length) {
-    parts.push(`CONCEPTS: ${analysis.concepts.join(', ')}`);
+    parts.push(`CONCEPTS: ${analysis.concepts.join(", ")}`);
   }
   if (analysis.styleHints?.length) {
-    parts.push(`STYLE HINTS: ${analysis.styleHints.join(', ')}`);
+    parts.push(`STYLE HINTS: ${analysis.styleHints.join(", ")}`);
   }
-  return parts.join('\n');
+  return parts.join("\n");
 }
+export {
+  analyzePrompt,
+  formatAnalysisForPrompt
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui-retrieval",
-  "version": "0.6.4",
+  "version": "0.6.7",
   "description": "AdiaUI A2UI retrieval layer \u2014 catalog lookup, intent classification, domain routing, pattern + anti-pattern matching, clarity + context assembly. Consumed by the compose engine and any A2UI-protocol tooling that needs to reason about user intent against the catalog.",
   "type": "module",
   "main": "./index.js",
@@ -63,7 +63,9 @@
     "feedback/",
     "authoring/",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "!**/*.ts",
+    "**/*.d.ts"
   ],
   "license": "MIT",
   "publishConfig": {