@adia-ai/a2ui-retrieval 0.0.1

package/pattern-promotion.js

@@ -0,0 +1,135 @@
+/**
+ * Pattern Promotion — Automatically identifies generations that should
+ * become reusable patterns based on quality signals and user feedback.
+ *
+ * Promotion criteria (all must be met):
+ *   - Generation score >= 95
+ *   - Feedback rating >= 4 (if feedback exists)
+ *   - Intent alignment score >= 0.8 (if checked)
+ *   - User didn't heavily edit the output
+ *   - Explicit shouldBePattern flag (from feedback) OR auto-detected
+ *
+ * Auto-detection: a generation is auto-promoted if it scores high on all
+ * dimensions and uses a novel combination of components not already in
+ * the pattern library.
+ */
+
+import { getAllPatterns } from './pattern-library.js';
+
+/**
+ * Evaluate whether a generation should be promoted to a named pattern.
+ *
+ * @param {object} opts
+ * @param {number} opts.score — Validation score (0-100)
+ * @param {object} [opts.feedback] — User feedback { rating, userEdited }
+ * @param {object} [opts.alignment] — Intent alignment { score }
+ * @param {string[]} opts.componentTypes — Component types used in generation
+ * @param {string} opts.intent — Original intent
+ * @returns {{ shouldPromote: boolean, confidence: number, reason: string, suggestedName: string }}
+ */
+export function evaluatePromotion({ score, feedback, alignment, componentTypes, intent }) {
+  let confidence = 0;
+  const reasons = [];
+
+  // ── Hard gates ──
+  if (score < 95) {
+    return { shouldPromote: false, confidence: 0, reason: `Score ${score} < 95`, suggestedName: '' };
+  }
+
+  // Score contribution (0.3 weight)
+  confidence += (score / 100) * 0.3;
+  reasons.push(`score: ${score}/100`);
+
+  // ── Feedback signals (0.3 weight) ──
+  if (feedback) {
+    if (feedback.rating >= 4) {
+      confidence += (feedback.rating / 5) * 0.2;
+      reasons.push(`rating: ${feedback.rating}/5`);
+    } else if (feedback.rating > 0) {
+      return { shouldPromote: false, confidence, reason: `Rating ${feedback.rating} < 4`, suggestedName: '' };
+    }
+
+    if (feedback.userEdited) {
+      confidence -= 0.15;
+      reasons.push('user edited (penalty)');
+    }
+
+    if (feedback.shouldBePattern) {
+      confidence += 0.15;
+      reasons.push('user flagged as pattern');
+    }
+  } else {
+    // No feedback — partial confidence from score alone
+    confidence += 0.1;
+  }
+
+  // ── Alignment signals (0.2 weight) ──
+  if (alignment) {
+    if (alignment.score >= 0.8) {
+      confidence += alignment.score * 0.2;
+      reasons.push(`alignment: ${Math.round(alignment.score * 100)}%`);
+    } else {
+      confidence -= 0.1;
+      reasons.push(`low alignment: ${Math.round(alignment.score * 100)}%`);
+    }
+  }
+
+  // ── Novelty bonus (0.2 weight) ──
+  const novelty = assessNovelty(componentTypes);
+  if (novelty > 0.5) {
+    confidence += novelty * 0.2;
+    reasons.push(`novelty: ${Math.round(novelty * 100)}%`);
+  }
+
+  // ── Decision ──
+  const shouldPromote = confidence >= 0.5;
+  const suggestedName = generatePatternName(intent);
+
+  return {
+    shouldPromote,
+    confidence: Math.round(confidence * 100) / 100,
+    reason: reasons.join(', '),
+    suggestedName,
+  };
+}
+
+/**
+ * Assess how novel a component combination is compared to existing patterns.
+ * Higher = more novel (not well-covered by existing patterns).
+ *
+ * @param {string[]} componentTypes
+ * @returns {number} — 0 (duplicate) to 1 (completely novel)
+ */
+function assessNovelty(componentTypes) {
+  const existing = getAllPatterns();
+  if (existing.length === 0) return 1;
+
+  const typeSet = new Set(componentTypes);
+  let bestOverlap = 0;
+
+  for (const pattern of existing) {
+    const patternTypes = new Set(pattern.components || []);
+    const intersection = [...typeSet].filter(t => patternTypes.has(t)).length;
+    const union = new Set([...typeSet, ...patternTypes]).size;
+    const jaccard = union > 0 ? intersection / union : 0;
+    bestOverlap = Math.max(bestOverlap, jaccard);
+  }
+
+  // Invert: high overlap = low novelty
+  return 1 - bestOverlap;
+}
+
+/**
+ * Generate a suggested pattern name from an intent string.
+ *
+ * @param {string} intent
+ * @returns {string}
+ */
+function generatePatternName(intent) {
+  return (intent || 'unnamed')
+    .toLowerCase()
+    .replace(/\b(create|build|make|show|add|generate|a|an|the|with|and|for|of)\b/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 40) || 'unnamed-pattern';
+}

package/prompt-analyzer.js

@@ -0,0 +1,211 @@
+/**
+ * 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 catalog = {};
+  try {
+    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');
+      const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+      const raw = await fs.readFile(path.join(__dirname, '../corpus/patterns/_components.json'), 'utf8');
+      catalog = JSON.parse(raw);
+    } else {
+      const resp = await fetch(new URL('../corpus/patterns/_components.json', import.meta.url));
+      if (resp.ok) catalog = await resp.json();
+    }
+  } catch { /* empty vocab — analyzer will still work, just unconstrained */ }
+
+  const displayList = [];
+  const allowedSet = new Set();
+  for (const [name, data] of Object.entries(catalog)) {
+    allowedSet.add(name);
+    const aliases = Array.isArray(data?.aliases) ? data.aliases : [];
+    for (const a of aliases) allowedSet.add(a);
+    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 }) {
+  const passthrough = {
+    raw: intent,
+    concepts: [],
+    entities: [],
+    impliedComponents: [],
+    styleHints: [],
+    steelman: intent,
+    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 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:
+{
+  "concepts": [string],          // 2-5 short concept tags (e.g. "commerce", "authentication", "data-display", "navigation")
+  "entities": [string],          // explicit nouns from the prompt (lowercase, singular)
+  "implied_components": [string],// 4-12 AdiaUI components a good designer would include
+  "style_hints": [string],       // visual/style adjectives ("minimal", "dense", "3D", "playful"), [] if none stated
+  "steelman": string             // 1-2 sentence enriched brief
+}
+
+AdiaUI components you may name in implied_components (use these names exactly): ${componentList}
+
+Rules:
+- Extract entities verbatim from the prompt — 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.
+- If the prompt is already well-specified (>15 words, multiple entities), the steelman is mostly a faithful restatement.
+
+Examples:
+Input: "product card"
+Output: {"concepts":["commerce","product-display"],"entities":["product"],"implied_components":["Card","Image","Text","Badge","Button"],"style_hints":[],"steelman":"E-commerce product card with image, title, price, optional sale badge, and primary 'Add to cart' button. Card layout, single product."}
+
+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."}`;
+
+  const userMsg = `Prompt: "${intent}"${domainHint}`;
+
+  let response;
+  try {
+    response = await llmAdapter.complete({
+      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') {
+    return passthrough;
+  }
+
+  // Try direct parse, then code-fence extraction, then outermost JSON.
+  let parsed = null;
+  try { parsed = JSON.parse(text.trim()); } catch { /* fall through */ }
+  if (!parsed) {
+    const fence = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+    if (fence) try { parsed = JSON.parse(fence[1].trim()); } catch { /* fall through */ }
+  }
+  if (!parsed) {
+    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 */ }
+    }
+  }
+  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)))
+    : [];
+
+  return {
+    raw: intent,
+    concepts:          asStringArray(parsed.concepts).slice(0, 8),
+    entities:          asStringArray(parsed.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,
+  };
+}
+
+function asStringArray(v) {
+  if (!Array.isArray(v)) return [];
+  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 '';
+  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(', ')}`);
+  }
+  if (analysis.concepts?.length) {
+    parts.push(`CONCEPTS: ${analysis.concepts.join(', ')}`);
+  }
+  if (analysis.styleHints?.length) {
+    parts.push(`STYLE HINTS: ${analysis.styleHints.join(', ')}`);
+  }
+  return parts.join('\n');
+}