@adia-ai/gen-ui 0.8.37

package/retrieval/feedback/human-signal.js

@@ -0,0 +1,113 @@
+const THUMB_UP_MIN = 4;
+const HUMAN_WEIGHT = 0.7;
+const SELF_WEIGHT = 0.3;
+function isType(entry, type) {
+  return entry["type"] === type;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function summarizeRatings(entries) {
+  const ratings = entries.filter((e) => isType(e, "rating"));
+  const up = ratings.filter((r) => (num(r["rating"]) ?? 0) >= THUMB_UP_MIN).length;
+  const down = ratings.length - up;
+  return {
+    up,
+    down,
+    total: ratings.length,
+    thumbUpRate: ratings.length > 0 ? Math.round(up / ratings.length * 100) : 0
+  };
+}
+function ratingDomain(rating, execDomainById) {
+  return str(rating["domain"]) ?? execDomainById.get(str(rating["executionId"]) ?? "");
+}
+function rankWeakDomains(entries, { limit = 10 } = {}) {
+  const executions = entries.filter((e) => isType(e, "execution"));
+  const ratings = entries.filter((e) => isType(e, "rating"));
+  const execDomainById = /* @__PURE__ */ new Map();
+  for (const e of executions) {
+    const id = str(e["executionId"]);
+    const domain = str(e["domain"]);
+    if (id && domain) execDomainById.set(id, domain);
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  const bucket = (domain) => {
+    let b = buckets.get(domain);
+    if (!b) {
+      b = { executions: 0, totalScore: 0, scoreSamples: 0, up: 0, down: 0 };
+      buckets.set(domain, b);
+    }
+    return b;
+  };
+  const addScore = (b, value) => {
+    const s = num(value);
+    if (s === void 0) return;
+    b.totalScore += s;
+    b.scoreSamples++;
+  };
+  for (const e of executions) {
+    const b = bucket(str(e["domain"]) ?? "unknown");
+    b.executions++;
+    addScore(b, e["score"]);
+  }
+  for (const r of ratings) {
+    const b = bucket(ratingDomain(r, execDomainById) ?? "unknown");
+    if ((num(r["rating"]) ?? 0) >= THUMB_UP_MIN) b.up++;
+    else b.down++;
+    addScore(b, r["score"]);
+  }
+  const ranked = [];
+  for (const [domain, b] of buckets) {
+    const humanRatings = b.up + b.down;
+    if (b.executions === 0 && humanRatings === 0) continue;
+    const hasSelf = b.scoreSamples > 0;
+    const hasHuman = humanRatings > 0;
+    const selfScore = hasSelf ? Math.round(b.totalScore / b.scoreSamples) : 0;
+    const humanScore = hasHuman ? Math.round(b.up / humanRatings * 100) : 0;
+    let blendedScore;
+    let signal;
+    if (hasHuman && hasSelf) {
+      blendedScore = Math.round(HUMAN_WEIGHT * humanScore + SELF_WEIGHT * selfScore);
+      signal = "human+self";
+    } else if (hasHuman) {
+      blendedScore = humanScore;
+      signal = "human";
+    } else if (hasSelf) {
+      blendedScore = selfScore;
+      signal = "self-only";
+    } else {
+      blendedScore = 0;
+      signal = "none";
+    }
+    ranked.push({
+      domain,
+      executions: b.executions,
+      selfScore,
+      selfScoreSamples: b.scoreSamples,
+      humanRatings,
+      humanScore,
+      blendedScore,
+      signal
+    });
+  }
+  ranked.sort((a, b) => {
+    const aNone = a.signal === "none";
+    const bNone = b.signal === "none";
+    if (aNone !== bNone) return aNone ? 1 : -1;
+    if (aNone) return b.executions - a.executions;
+    return a.blendedScore - b.blendedScore || b.humanRatings - a.humanRatings;
+  });
+  return ranked.slice(0, limit);
+}
+const WEIGHTING_RULE = `blendedScore = ${HUMAN_WEIGHT} * humanScore + ${SELF_WEIGHT} * selfScore when a domain has BOTH signals; humanScore alone when it has no self-grade; selfScore alone when it has no thumbs; signal 'none' when it has neither \u2014 those are unranked and sort after every ranked domain, not at the weak end. A missing signal is not a zero. Human thumb outweighs the self-grade on conflict. selfScore averages execution scores plus any score carried inline on a rating; engine/strategy are recorded for triage but are not ranked on.`;
+export {
+  HUMAN_WEIGHT,
+  SELF_WEIGHT,
+  THUMB_UP_MIN,
+  WEIGHTING_RULE,
+  rankWeakDomains,
+  summarizeRatings
+};

package/retrieval/feedback/index.d.ts

@@ -0,0 +1,4 @@
+// v0.5.21 hotfix stub — TS-migration Phase 1 (568bb998d) declared this
+// types: export but Phase 2 hasn't generated real declarations yet.
+// Replace with real type declarations when Phase 2 lands.
+export {};

package/retrieval/feedback/index.js

@@ -0,0 +1,24 @@
+import { feedbackStore } from "./feedback-store.js";
+import { submitFeedback, FeedbackValidationError } from "./submit-feedback.js";
+import { rankWeakDomains, summarizeRatings, HUMAN_WEIGHT, SELF_WEIGHT, THUMB_UP_MIN, WEIGHTING_RULE } from "./human-signal.js";
+import { FeedbackAnalyzer } from "./feedback-analyzer.js";
+export * from "./feedback.js";
+import { recordTurn, isRecording } from "./dialog-recorder.js";
+import { loadGaps, addGap, updateGapStatus } from "./gap-registry.js";
+export {
+  FeedbackAnalyzer,
+  FeedbackValidationError,
+  HUMAN_WEIGHT,
+  SELF_WEIGHT,
+  THUMB_UP_MIN,
+  WEIGHTING_RULE,
+  addGap,
+  feedbackStore,
+  isRecording,
+  loadGaps,
+  rankWeakDomains,
+  recordTurn,
+  submitFeedback,
+  summarizeRatings,
+  updateGapStatus
+};

package/retrieval/feedback/submit-feedback.js

@@ -0,0 +1,45 @@
+import { feedbackStore } from "./feedback-store.js";
+import { THUMB_UP_MIN } from "./human-signal.js";
+class FeedbackValidationError extends Error {
+  status = 400;
+  name = "FeedbackValidationError";
+}
+const MAX_TEXT = 2e3;
+function text(value, max = MAX_TEXT) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, max) : void 0;
+}
+function score(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+async function submitFeedback(input) {
+  const executionId = text(input?.executionId, 200);
+  if (!executionId) throw new FeedbackValidationError("executionId is required");
+  const rating = typeof input?.rating === "number" && Number.isFinite(input.rating) ? Math.round(input.rating) : NaN;
+  if (!(rating >= 1 && rating <= 5)) throw new FeedbackValidationError("rating must be a number 1-5");
+  const source = text(input?.source, 60) ?? "unknown";
+  await feedbackStore.logRating({
+    executionId,
+    rating,
+    intent: text(input?.intent) ?? "",
+    domain: text(input?.domain, 120),
+    engine: text(input?.engine, 60),
+    strategy: text(input?.strategy, 60),
+    score: score(input?.score),
+    source,
+    notes: text(input?.notes)
+  });
+  return {
+    recorded: true,
+    executionId,
+    rating,
+    thumb: rating >= THUMB_UP_MIN ? "up" : "down",
+    source
+  };
+}
+export {
+  FeedbackValidationError,
+  submitFeedback
+};

package/retrieval/index.d.ts

@@ -0,0 +1,4 @@
+// v0.5.21 hotfix stub — TS-migration Phase 1 (568bb998d) declared this
+// types: export but Phase 2 hasn't generated real declarations yet.
+// Replace with real type declarations when Phase 2 lands.
+export {};

package/retrieval/index.js

@@ -0,0 +1,53 @@
+import {
+  getCatalog,
+  getComponent,
+  getComponentsByCategory,
+  getTraits,
+  getTraitsByCategory,
+  getFullCatalog
+} from "./catalog.js";
+import { serializeEntry } from "./component-entry.js";
+import { getAntiPatterns, checkAntiPattern, checkAllAntiPatterns } from "./anti-patterns.js";
+import { classifyIntent, getDomain, getAllDomains } from "./domain-router.js";
+import { isConversational } from "./intent/intent-gate.js";
+import { assessClarity } from "./intent/clarity.js";
+import { detectReferences, researchIntent } from "./authoring/web-research.js";
+import { assembleContext } from "./context-assembler.js";
+import { getComponentData, getAllComponentData } from "./component-catalog.js";
+import {
+  extractExpectations,
+  verifyAlignment,
+  checkIntentAlignment
+} from "./intent/intent-alignment.js";
+import { decomposeIntent, composeSubtasks } from "./intent/decomposer.js";
+import { getWiringCatalog, getControllerInfo, getHandlerInfo } from "./wiring-catalog.js";
+export {
+  assembleContext,
+  assessClarity,
+  checkAllAntiPatterns,
+  checkAntiPattern,
+  checkIntentAlignment,
+  classifyIntent,
+  composeSubtasks,
+  decomposeIntent,
+  detectReferences,
+  extractExpectations,
+  getAllComponentData,
+  getAllDomains,
+  getAntiPatterns,
+  getCatalog,
+  getComponent,
+  getComponentData,
+  getComponentsByCategory,
+  getControllerInfo,
+  getDomain,
+  getFullCatalog,
+  getHandlerInfo,
+  getTraits,
+  getTraitsByCategory,
+  getWiringCatalog,
+  isConversational,
+  researchIntent,
+  serializeEntry,
+  verifyAlignment
+};

package/retrieval/intent/clarity.js

@@ -0,0 +1,139 @@
+import { classifyIntent } from "../domain-router.js";
+import { searchAll as searchCompositions } from "../../compose/strategies/zettel/composition-library.js";
+const SCOPE_SIGNALS = [
+  /\b\d+\b/,
+  // contains a number
+  /\b(three|two|four|five|six)\b/i,
+  // spelled-out numbers
+  /\b(with|containing|including|showing|displaying)\b/i,
+  // enumerates content
+  /\b(and|plus|also)\b/i,
+  // multiple items
+  /\b(columns?|rows?|items?|cards?|sections?|fields?|buttons?|tabs?|steps?)\b/i
+  // structural counts
+];
+const CONTENT_SIGNALS = [
+  /\b(name|email|password|title|description|price|date|status|role|avatar)\b/i,
+  /\b(revenue|users|growth|sales|orders|metrics|analytics)\b/i,
+  /\b(todo|done|in progress|pending|active|completed)\b/i,
+  /\b(bleed|margin|trim|crop|preview|artwork|brand|design system)\b/i,
+  /\b(approved|approval|production|settings|configure|preference)\b/i,
+  /["'][\w\s]+["']/,
+  // quoted strings (specific labels)
+  /\$[\d,.]+/,
+  // dollar amounts
+  /\d+%/
+  // percentages
+];
+const LAYOUT_SIGNALS = [
+  /\b(grid|row|column|sidebar|split|horizontal|vertical|stack|centered)\b/i,
+  /\b(full.?width|responsive|mobile|compact|wide|narrow)\b/i,
+  /\b(\d+.?col(umn)?s?)\b/i,
+  // "3 columns", "2-col"
+  /\b(left|right|top|bottom|center)\b/i
+];
+const ACTION_SIGNALS = [
+  /\b(button|submit|cancel|save|delete|edit|close|open|toggle|click)\b/i,
+  /\b(form|input|select|search|filter|sort|upload|download)\b/i,
+  /\b(login|signup|register|checkout|confirm|approve|reject)\b/i,
+  /\b(navigate|link|redirect|route)\b/i,
+  /\b(drag|drop|resize|expand|collapse)\b/i
+];
+function assessClarity(intent, classification) {
+  const text = (intent ?? "").trim();
+  if (!text) {
+    return {
+      clear: false,
+      score: 0,
+      dimensions: { domain: 0, scope: 0, content: 0, layout: 0, action: 0 },
+      questions: [{ text: "What would you like me to build?", dimension: "domain", priority: 1 }],
+      summary: "No intent provided"
+    };
+  }
+  const cls = classification || classifyIntent(text);
+  const compositionMatches = searchCompositions(text);
+  const wordCount = text.split(/\s+/).length;
+  const domainScore = cls.confidence >= 0.3 ? 1 : cls.confidence >= 0.15 ? 0.6 : cls.matchedSignals.length > 0 ? 0.3 : 0;
+  const scopeHits = SCOPE_SIGNALS.filter((r) => r.test(text)).length;
+  const scopeScore = Math.min(1, scopeHits / 2);
+  const contentHits = CONTENT_SIGNALS.filter((r) => r.test(text)).length;
+  const contentScore = Math.min(1, contentHits / 2);
+  const layoutHits = LAYOUT_SIGNALS.filter((r) => r.test(text)).length;
+  const layoutScore = Math.min(1, layoutHits);
+  const actionHits = ACTION_SIGNALS.filter((r) => r.test(text)).length;
+  const actionScore = Math.min(1, actionHits / 2);
+  const score = domainScore * 0.25 + scopeScore * 0.25 + contentScore * 0.2 + layoutScore * 0.15 + actionScore * 0.15;
+  const patternBonus = compositionMatches.length > 0 ? 0.15 : 0;
+  const lengthBonus = wordCount > 10 ? 0.1 : wordCount > 6 ? 0.05 : 0;
+  const finalScore = Math.min(1, score + patternBonus + lengthBonus);
+  const questions = [];
+  if (domainScore < 0.3) {
+    questions.push({
+      text: "What type of UI is this? (e.g., a form, dashboard, profile card, settings page)",
+      dimension: "domain",
+      priority: 1
+    });
+  }
+  if (scopeScore < 0.5) {
+    const domainQuestions = {
+      forms: "What fields should the form include?",
+      data: "What data should be displayed? How many items or metrics?",
+      layout: "How many sections or cards should it have?",
+      agent: "What actions should the assistant support?",
+      navigation: "What pages or sections should be navigable?"
+    };
+    questions.push({
+      text: domainQuestions[cls.domain] ?? "Can you be more specific about what it should contain?",
+      dimension: "scope",
+      priority: 2
+    });
+  }
+  if (contentScore < 0.3 && scopeScore >= 0.3) {
+    const contentQuestions = {
+      forms: 'What labels should the fields have? (e.g., "Email", "Password", "Full Name")',
+      data: "What metrics or values should be shown? (e.g., revenue, users, growth rate)",
+      layout: "What content goes in each section?",
+      agent: "What kind of messages or responses should be shown?",
+      navigation: "What should the menu items or links be labeled?"
+    };
+    questions.push({
+      text: contentQuestions[cls.domain] ?? "What specific content should be displayed?",
+      dimension: "content",
+      priority: 3
+    });
+  }
+  if (layoutScore < 0.3 && scopeScore >= 0.5) {
+    questions.push({
+      text: "Any layout preference? (e.g., grid of cards, single column, sidebar + content)",
+      dimension: "layout",
+      priority: 4
+    });
+  }
+  if (actionScore < 0.3 && domainScore >= 0.3) {
+    questions.push({
+      text: "What actions should users be able to take? (e.g., submit, edit, delete, filter)",
+      dimension: "action",
+      priority: 5
+    });
+  }
+  questions.sort((a, b) => a.priority - b.priority);
+  const topQuestions = questions.slice(0, 3);
+  const clear = finalScore >= 0.4;
+  const summary = clear ? `Intent is ${finalScore >= 0.7 ? "clear" : "adequate"} (${Math.round(finalScore * 100)}%)` : `Intent needs clarification (${Math.round(finalScore * 100)}% \u2014 below 40% threshold)`;
+  return {
+    clear,
+    score: Math.round(finalScore * 100) / 100,
+    dimensions: {
+      domain: Math.round(domainScore * 100) / 100,
+      scope: Math.round(scopeScore * 100) / 100,
+      content: Math.round(contentScore * 100) / 100,
+      layout: Math.round(layoutScore * 100) / 100,
+      action: Math.round(actionScore * 100) / 100
+    },
+    questions: topQuestions,
+    summary
+  };
+}
+export {
+  assessClarity
+};

package/retrieval/intent/decomposer.js

@@ -0,0 +1,124 @@
+import { classifyIntent } from "../domain-router.js";
+const SECTION_SPLITTERS = /\band\b|\bwith\b|\bplus\b|\balso\b|,\s*(?:and\s+)?/gi;
+const SECTION_SIGNALS = [
+  /\b(\d+)\s+(sections?|areas?|parts?|panels?|columns?|cards?|tabs?|pages?|views?)\b/i,
+  /\bsections?:\s/i,
+  /\bincluding\b/i,
+  /\beach\s+(with|having|containing)\b/i
+];
+const LAYOUT_KEYWORDS = {
+  tabs: { component: "Tabs", child: "Tab" },
+  sections: { component: "Column", child: "Card" },
+  columns: { component: "Grid", child: "Column" },
+  cards: { component: "Grid", child: "Card" },
+  panels: { component: "Accordion", child: "Panel" },
+  pages: { component: "Tabs", child: "Tab" },
+  areas: { component: "Grid", child: "Card" },
+  steps: { component: "Steps", child: "Step" }
+};
+function decomposeIntent(intent) {
+  const trimmed = (intent || "").trim();
+  if (!trimmed) return { shouldDecompose: false, subtasks: [], layout: null, original: trimmed };
+  for (const pattern of SECTION_SIGNALS) {
+    if (pattern.test(trimmed)) {
+      const sections2 = extractSections(trimmed);
+      if (sections2.length >= 2) {
+        const layout = detectLayout(trimmed, sections2.length);
+        return {
+          shouldDecompose: true,
+          subtasks: sections2,
+          layout,
+          original: trimmed
+        };
+      }
+    }
+  }
+  const sections = extractSections(trimmed);
+  if (sections.length >= 2) {
+    const layout = detectLayout(trimmed, sections.length);
+    return {
+      shouldDecompose: true,
+      subtasks: sections,
+      layout,
+      original: trimmed
+    };
+  }
+  return { shouldDecompose: false, subtasks: [], layout: null, original: trimmed };
+}
+function extractSections(intent) {
+  const withMatch = intent.match(/\bwith\s+(.+)$/i);
+  const payload = withMatch ? withMatch[1] ?? intent : intent;
+  const parts = payload.split(SECTION_SPLITTERS).map((s) => s.trim()).filter((s) => s.length > 2);
+  if (parts.length < 2) return [];
+  const baseContext = withMatch ? intent.slice(0, withMatch.index).trim() : "";
+  const domain = classifyIntent(intent).domain;
+  void domain;
+  return parts.map((part) => {
+    const label = part.replace(/\b(section|area|panel|tab|page)\b/gi, "").trim();
+    const subtaskIntent = baseContext ? `${label} section for a ${baseContext}` : `${label}`;
+    return { intent: subtaskIntent, label: capitalizeFirst(label) };
+  });
+}
+function detectLayout(intent, sectionCount) {
+  const lower = intent.toLowerCase();
+  for (const [keyword, layout] of Object.entries(LAYOUT_KEYWORDS)) {
+    if (lower.includes(keyword)) return layout;
+  }
+  if (lower.includes("settings") || lower.includes("preferences") || lower.includes("account")) {
+    return { component: "Tabs", child: "Tab" };
+  }
+  if (lower.includes("dashboard") || lower.includes("overview") || lower.includes("stat")) {
+    return { component: "Grid", child: "Card" };
+  }
+  if (sectionCount <= 4) return { component: "Tabs", child: "Tab" };
+  return { component: "Grid", child: "Card" };
+}
+function composeSubtasks(layout, subtaskResults) {
+  const rootChildren = [];
+  const allComponents = [];
+  let idCounter = 0;
+  for (const { label, messages } of subtaskResults) {
+    const prefix = `s${++idCounter}`;
+    const subtaskComponents = messages?.[0]?.components ?? [];
+    const idMap = /* @__PURE__ */ new Map();
+    const remapped = subtaskComponents.map((c) => {
+      const newId = c.id === "root" ? prefix : `${prefix}-${c.id}`;
+      idMap.set(c.id, newId);
+      return { ...c, id: newId };
+    });
+    for (const c of remapped) {
+      if (c.children) {
+        c.children = c.children.map((id) => idMap.get(id) ?? id);
+      }
+    }
+    if (layout.child === "Tab") {
+      const tabId = `${prefix}-tab`;
+      allComponents.push({ id: tabId, component: "Tab", text: label, children: [prefix] });
+      rootChildren.push(tabId);
+    } else {
+      rootChildren.push(prefix);
+    }
+    allComponents.push(...remapped);
+  }
+  const root = {
+    id: "root",
+    component: layout.component,
+    children: rootChildren
+  };
+  if (layout.component === "Grid") {
+    root["columns"] = String(Math.min(subtaskResults.length, 4));
+    root["gap"] = "md";
+  }
+  return [{
+    type: "updateComponents",
+    surfaceId: "default",
+    components: [root, ...allComponents]
+  }];
+}
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+export {
+  composeSubtasks,
+  decomposeIntent
+};

package/retrieval/intent/index.d.ts

@@ -0,0 +1,4 @@
+// v0.5.21 hotfix stub — TS-migration Phase 1 (568bb998d) declared this
+// types: export but Phase 2 hasn't generated real declarations yet.
+// Replace with real type declarations when Phase 2 lands.
+export {};

package/retrieval/intent/index.js

@@ -0,0 +1,18 @@
+import { extractExpectations, verifyAlignment, checkIntentAlignment } from "./intent-alignment.js";
+import { categorizeIntent } from "./intent-categorizer.js";
+import { isConversational } from "./intent-gate.js";
+import { analyzePrompt, formatAnalysisForPrompt } from "./prompt-analyzer.js";
+import { decomposeIntent, composeSubtasks } from "./decomposer.js";
+import { assessClarity } from "./clarity.js";
+export {
+  analyzePrompt,
+  assessClarity,
+  categorizeIntent,
+  checkIntentAlignment,
+  composeSubtasks,
+  decomposeIntent,
+  extractExpectations,
+  formatAnalysisForPrompt,
+  isConversational,
+  verifyAlignment
+};