@adia-ai/a2ui-retrieval 0.6.4 → 0.6.6

package/feedback/feedback.js

@@ -1,198 +1,117 @@
-/**
- * FeedbackCollector — Structured feedback for the evolution engine.
- *
- * Captures per-generation feedback across multiple dimensions:
- *   - Overall rating (1-5)
- *   - Intent alignment, visual quality, component choice (1-5 each)
- *   - Whether the user edited the output
- *   - Pattern promotion signals ("this should become a pattern")
- *
- * Exports as a structured JSON log for the training cycle.
- */
-
-/**
- * @typedef {object} FeedbackEntry
- * @property {string} executionId
- * @property {string} intent
- * @property {string} domain
- * @property {string} mode
- * @property {number} timestamp
- * @property {object} generation
- * @property {number} generation.componentCount
- * @property {string[]} generation.componentTypes
- * @property {number} generation.score
- * @property {{ name: string, passed: boolean }[]} generation.validationChecks
- * @property {{ structural: number, completeness: number, idiomatic: number, minimal: number }} generation.qualityDimensions
- * @property {object} feedback
- * @property {number} [feedback.rating]
- * @property {number} [feedback.intentAlignment]
- * @property {number} [feedback.visualQuality]
- * @property {number} [feedback.componentChoice]
- * @property {boolean} [feedback.userEdited]
- * @property {string} [feedback.editSummary]
- * @property {string} [feedback.notes]
- * @property {object} patterns
- * @property {string} [patterns.patternUsed]
- * @property {boolean} [patterns.shouldBePattern]
- * @property {string} [patterns.suggestedName]
- */
-
-export class FeedbackCollector {
-  /** @type {Map<string, FeedbackEntry>} */
-  #entries = new Map();
-
+class FeedbackCollector {
+  #entries = /* @__PURE__ */ new Map();
   /**
    * Initialize a feedback entry from generation results.
    * Called automatically after each generation completes.
-   *
-   * @param {string} executionId
-   * @param {object} data
-   * @param {string} data.intent
-   * @param {string} data.domain
-   * @param {string} data.mode
-   * @param {object[]} data.messages
-   * @param {object} data.validation
    */
   initFromGeneration(executionId, { intent, domain, mode, messages, validation }) {
-    const components = messages?.[0]?.components || [];
-    const checks = validation?.checks || [];
-
-    // Compute quality dimensions (same logic as score_quality in mcp-tools.js)
-    const failedChecks = checks.filter(c => !c.passed);
-    const structural = failedChecks.some(c =>
-      ['hasRootComponent', 'noOrphanedChildren', 'flatAdjacency'].includes(c.name)
+    const components = messages?.[0]?.components ?? [];
+    const checks = validation?.checks ?? [];
+    const failedChecks = checks.filter((c) => !c.passed);
+    const structural = failedChecks.some(
+      (c) => ["hasRootComponent", "noOrphanedChildren", "flatAdjacency"].includes(c.name)
     ) ? 0.5 : 1;
-    const completeness = Math.max(0, 1 - (
-      failedChecks.filter(c => ['textContentSet', 'allTypesRegistered'].includes(c.name)).length * 0.1
-    ));
-    const idiomatic = failedChecks.some(c =>
-      ['noBareDivs', 'noBareInputs', 'cardStructure'].includes(c.name)
+    const completeness = Math.max(0, 1 - failedChecks.filter((c) => ["textContentSet", "allTypesRegistered"].includes(c.name)).length * 0.1);
+    const idiomatic = failedChecks.some(
+      (c) => ["noBareDivs", "noBareInputs", "cardStructure"].includes(c.name)
     ) ? 0.5 : 1;
-    const minimal = failedChecks.some(c =>
-      ['noHardcodedColors', 'noInlineLayout'].includes(c.name)
+    const minimal = failedChecks.some(
+      (c) => ["noHardcodedColors", "noInlineLayout"].includes(c.name)
     ) ? 0.5 : 1;
-
     this.#entries.set(executionId, {
       executionId,
-      intent: intent || '',
-      domain: domain || '',
-      mode: mode || 'instant',
+      intent: intent ?? "",
+      domain: domain ?? "",
+      mode: mode ?? "instant",
       timestamp: Date.now(),
       generation: {
         componentCount: components.length,
-        componentTypes: [...new Set(components.map(c => c.component).filter(Boolean))],
+        componentTypes: [...new Set(components.map((c) => c.component).filter((x) => Boolean(x)))],
         score: validation?.score ?? 0,
-        validationChecks: checks.map(c => ({ name: c.name, passed: c.passed })),
-        qualityDimensions: { structural, completeness, idiomatic, minimal },
+        validationChecks: checks.map((c) => ({ name: c.name, passed: c.passed })),
+        qualityDimensions: { structural, completeness, idiomatic, minimal }
       },
       feedback: {},
-      patterns: {},
+      patterns: {}
     });
   }
-
   /**
    * Collect user feedback for an execution.
-   *
-   * @param {string} executionId
-   * @param {object} feedback
-   * @param {number} [feedback.rating] — 1-5
-   * @param {number} [feedback.intentAlignment] — 1-5
-   * @param {number} [feedback.visualQuality] — 1-5
-   * @param {number} [feedback.componentChoice] — 1-5
-   * @param {boolean} [feedback.userEdited]
-   * @param {string} [feedback.editSummary]
-   * @param {string} [feedback.notes]
    */
   collectFeedback(executionId, feedback) {
     const entry = this.#entries.get(executionId);
     if (!entry) {
-      // Create a minimal entry if init wasn't called
       this.#entries.set(executionId, {
         executionId,
-        intent: '', domain: '', mode: '', timestamp: Date.now(),
-        generation: { componentCount: 0, componentTypes: [], score: 0, validationChecks: [], qualityDimensions: {} },
+        intent: "",
+        domain: "",
+        mode: "",
+        timestamp: Date.now(),
+        generation: { componentCount: 0, componentTypes: [], score: 0, validationChecks: [], qualityDimensions: { structural: 0, completeness: 0, idiomatic: 0, minimal: 0 } },
         feedback: {},
-        patterns: {},
+        patterns: {}
       });
     }
     const e = this.#entries.get(executionId);
     e.feedback = { ...e.feedback, ...feedback };
   }
-
   /**
    * Collect pattern-related feedback.
-   *
-   * @param {string} executionId
-   * @param {object} patternFeedback
-   * @param {string} [patternFeedback.patternUsed]
-   * @param {boolean} [patternFeedback.shouldBePattern]
-   * @param {string} [patternFeedback.suggestedName]
    */
   collectPatternFeedback(executionId, patternFeedback) {
     const entry = this.#entries.get(executionId);
     if (!entry) return;
     entry.patterns = { ...entry.patterns, ...patternFeedback };
   }
-
   /**
    * Get a single feedback entry.
-   * @param {string} executionId
-   * @returns {FeedbackEntry|null}
    */
   get(executionId) {
     return this.#entries.get(executionId) ?? null;
   }
-
   /**
    * Get all feedback entries.
-   * @returns {FeedbackEntry[]}
    */
   getAll() {
     return [...this.#entries.values()];
   }
-
   /** Number of entries. */
   get size() {
     return this.#entries.size;
   }
-
   /**
    * Export all feedback as structured JSON.
    * In browser: triggers a file download.
    * In Node: returns the JSON string.
-   *
-   * @returns {string} — JSON string of all entries
    */
   exportFeedback() {
     const data = {
-      exportedAt: new Date().toISOString(),
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
       entryCount: this.#entries.size,
-      entries: this.getAll(),
+      entries: this.getAll()
     };
     const json = JSON.stringify(data, null, 2);
-
-    // Browser download
-    if (typeof document !== 'undefined') {
-      const date = new Date().toISOString().slice(0, 10);
-      const blob = new Blob([json], { type: 'application/json' });
+    if (typeof document !== "undefined") {
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const blob = new Blob([json], { type: "application/json" });
       const url = URL.createObjectURL(blob);
-      const a = document.createElement('a');
+      const a = document.createElement("a");
       a.href = url;
       a.download = `gen-ui-feedback-${date}.json`;
-      a.style.display = 'none';
-      // Prevent SPA router from intercepting the blob URL click
-      a.addEventListener('click', (e) => e.stopPropagation());
+      a.style.display = "none";
+      a.addEventListener("click", (e) => e.stopPropagation());
       document.body.appendChild(a);
       a.click();
       document.body.removeChild(a);
       URL.revokeObjectURL(url);
     }
-
     return json;
   }
-
   /** Clear all entries. */
   clear() {
     this.#entries.clear();
   }
 }
+export {
+  FeedbackCollector
+};

package/feedback/gap-registry.js

@@ -1,122 +1,80 @@
-/**
- * Gap Registry
- *
- * Manages a persistent JSON file tracking identified pattern/training gaps.
- * Used by the feedback pipeline to record and track resolution of weak areas.
- *
- * Registry file: packages/a2ui/corpus/gaps/registry.json
- *
- * Usage:
- *   import { loadGaps, addGap, updateGapStatus } from './gap-registry.js';
- *   const gaps = await loadGaps();
- *   await addGap({ intentCategory: 'form/checkout', ... });
- *   await updateGapStatus('form/checkout', 'resolved', 'Added checkout pattern');
- */
-
-let fs, path;
-const IS_NODE = typeof process !== 'undefined' && process.versions?.node;
+let fs = null;
+let path = null;
+const IS_NODE = typeof process !== "undefined" && process.versions?.node;
 if (IS_NODE) {
   try {
-    fs = await import(/* @vite-ignore */ 'node:fs/promises');
-    path = await import(/* @vite-ignore */ 'node:path');
+    fs = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    path = await import(
+      /* @vite-ignore */
+      "node:path"
+    );
   } catch {
-    // Node builtins unavailable
   }
 }
-
-// packages/a2ui/retrieval/feedback → up 3 → packages/a2ui → corpus/gaps/registry.json
-const REGISTRY_PATH = path
-  ? path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'a2ui/corpus', 'gaps', 'registry.json')
-  : null;
-
-/**
- * Load all gaps from the registry file.
- * @returns {Promise<object[]>}
- */
-export async function loadGaps() {
+const REGISTRY_PATH = path ? path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "a2ui/corpus", "gaps", "registry.json") : null;
+async function loadGaps() {
   if (!fs || !REGISTRY_PATH) return [];
   try {
-    const content = await fs.readFile(REGISTRY_PATH, 'utf8');
+    const content = await fs.readFile(REGISTRY_PATH, "utf8");
     return JSON.parse(content);
   } catch {
     return [];
   }
 }
-
-/**
- * Save the full gaps array to disk.
- * @param {object[]} gaps
- */
-export async function saveGaps(gaps) {
+async function saveGaps(gaps) {
   if (!fs || !REGISTRY_PATH) return;
   const dir = path.dirname(REGISTRY_PATH);
   await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(REGISTRY_PATH, JSON.stringify(gaps, null, 2) + '\n');
+  await fs.writeFile(REGISTRY_PATH, JSON.stringify(gaps, null, 2) + "\n");
 }
-
-/**
- * Add a new gap to the registry. Merges with existing if same intentCategory.
- *
- * @param {object} gap
- * @param {string} gap.intentCategory
- * @param {number} gap.sampleCount
- * @param {number} gap.avgScore
- * @param {number} gap.avgRating
- * @param {string[]} gap.sampleIntents
- */
-export async function addGap(gap) {
+async function addGap(gap) {
   const gaps = await loadGaps();
-  const existing = gaps.find(g => g.intentCategory === gap.intentCategory && g.status !== 'resolved');
-
+  const existing = gaps.find((g) => g.intentCategory === gap.intentCategory && g.status !== "resolved");
   if (existing) {
-    // Merge: update stats, add new sample intents
-    existing.sampleCount = gap.sampleCount;
-    existing.avgScore = gap.avgScore;
-    existing.avgRating = gap.avgRating;
-    existing.lastSeen = new Date().toISOString();
-    const intentSet = new Set([...existing.sampleIntents, ...(gap.sampleIntents || [])]);
+    existing.sampleCount = gap.sampleCount ?? existing.sampleCount;
+    existing.avgScore = gap.avgScore ?? existing.avgScore;
+    existing.avgRating = gap.avgRating ?? existing.avgRating;
+    existing.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    const intentSet = /* @__PURE__ */ new Set([...existing.sampleIntents, ...gap.sampleIntents ?? []]);
     existing.sampleIntents = [...intentSet].slice(0, 10);
   } else {
     gaps.push({
       intentCategory: gap.intentCategory,
-      detectedAt: new Date().toISOString(),
-      lastSeen: new Date().toISOString(),
-      sampleCount: gap.sampleCount || 0,
-      avgScore: gap.avgScore || 0,
-      avgRating: gap.avgRating || 0,
-      status: 'open',
+      detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      sampleCount: gap.sampleCount ?? 0,
+      avgScore: gap.avgScore ?? 0,
+      avgRating: gap.avgRating ?? 0,
+      status: "open",
       resolution: null,
-      sampleIntents: (gap.sampleIntents || []).slice(0, 10),
+      sampleIntents: (gap.sampleIntents ?? []).slice(0, 10)
     });
   }
-
   await saveGaps(gaps);
   return gaps;
 }
-
-/**
- * Update the status of a gap by intent category.
- *
- * @param {string} category — Intent category to update
- * @param {'open'|'in-progress'|'resolved'} status
- * @param {string} [resolution] — Description of how the gap was resolved
- */
-export async function updateGapStatus(category, status, resolution) {
+async function updateGapStatus(category, status, resolution) {
   const gaps = await loadGaps();
-  const gap = gaps.find(g => g.intentCategory === category && g.status !== 'resolved');
-
+  const gap = gaps.find((g) => g.intentCategory === category && g.status !== "resolved");
   if (!gap) {
     throw new Error(`No open gap found for category: ${category}`);
   }
-
   gap.status = status;
   if (resolution) {
     gap.resolution = resolution;
   }
-  if (status === 'resolved') {
-    gap.resolvedAt = new Date().toISOString();
+  if (status === "resolved") {
+    gap.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
   }
-
   await saveGaps(gaps);
   return gap;
 }
+export {
+  addGap,
+  loadGaps,
+  saveGaps,
+  updateGapStatus
+};

package/feedback/index.js

@@ -1,12 +1,14 @@
-/**
- * @adia-ai/a2ui-retrieval/feedback — feedback-loop surface.
- *
- * Pairs the feedback store, analyzer, dialog recorder, and gap registry
- * — all the artifacts that compose the user-feedback ingestion loop.
- */
-
-export { feedbackStore } from './feedback-store.js';
-export { FeedbackAnalyzer } from './feedback-analyzer.js';
-export * from './feedback.js';
-export { recordTurn, isRecording } from './dialog-recorder.js';
-export { loadGaps, addGap, updateGapStatus } from './gap-registry.js';
+import { feedbackStore } from "./feedback-store.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,
+  addGap,
+  feedbackStore,
+  isRecording,
+  loadGaps,
+  recordTurn,
+  updateGapStatus
+};

package/index.js

@@ -1,16 +1,53 @@
-/**
- * A2UI Intelligence System — Public API
- */
-
-export { getCatalog, getComponent, getComponentsByCategory, getTraits, getTraitsByCategory, getFullCatalog } from './catalog.js';
-export { serializeEntry } from './component-entry.js';
-export { getAntiPatterns, checkAntiPattern, checkAllAntiPatterns } from './anti-patterns.js';
-export { classifyIntent, getDomain, getAllDomains } from './domain-router.js';
-export { isConversational } from './intent/intent-gate.js';
-export { assessClarity } from './intent/clarity.js';
-export { detectReferences, researchIntent } from './authoring/web-research.js';
-export { assembleContext } from './context-assembler.js';
-export { getComponentData, getAllComponentData } from './component-catalog.js';
-export { extractExpectations, verifyAlignment, checkIntentAlignment } from './intent/intent-alignment.js';
-export { decomposeIntent, composeSubtasks } from './intent/decomposer.js';
-export { getWiringCatalog, getControllerInfo, getHandlerInfo } from './wiring-catalog.js';
+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
+};