@adia-ai/a2ui-retrieval 0.6.2 → 0.6.6

package/feedback/feedback-analyzer.js

@@ -1,116 +1,78 @@
-/**
- * Feedback Analyzer
- *
- * Reads JSONL feedback files, aggregates by intent category,
- * and surfaces weak intents, promotion candidates, and pattern gaps.
- *
- * Usage:
- *   import { FeedbackAnalyzer } from './feedback-analyzer.js';
- *   const analyzer = new FeedbackAnalyzer();
- *   const entries = await analyzer.readRange(30);
- *   const aggregated = analyzer.aggregateByIntent(entries);
- *   const weak = analyzer.findWeakIntents(aggregated);
- */
-
-import { feedbackStore } from './feedback-store.js';
-import { categorizeIntent } from '../intent/intent-categorizer.js';
-
-let fs, path;
-const IS_NODE = typeof process !== 'undefined' && process.versions?.node;
+import { feedbackStore } from "./feedback-store.js";
+import { categorizeIntent } from "../intent/intent-categorizer.js";
+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/feedback
-const FEEDBACK_DIR = path
-  ? path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'a2ui/corpus', 'feedback')
-  : null;
-
-export class FeedbackAnalyzer {
+const FEEDBACK_DIR = path ? path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "a2ui/corpus", "feedback") : null;
+class FeedbackAnalyzer {
   /**
    * Read JSONL feedback files for the last N days.
-   *
-   * @param {number} days — Number of days to look back (default 30)
-   * @returns {Promise<object[]>} — Array of parsed feedback entries
    */
   async readRange(days = 30) {
     if (!fs || !FEEDBACK_DIR) return [];
-
     const entries = [];
-    const now = new Date();
-
-    // Build set of date strings we want
-    const dateStrings = new Set();
+    const now = /* @__PURE__ */ new Date();
+    const dateStrings = /* @__PURE__ */ new Set();
     for (let i = 0; i < days; i++) {
       const d = new Date(now);
       d.setDate(d.getDate() - i);
       dateStrings.add(d.toISOString().slice(0, 10));
     }
-
     try {
       const files = await fs.readdir(FEEDBACK_DIR);
-      const jsonlFiles = files
-        .filter(f => f.endsWith('.jsonl'))
-        .filter(f => {
-          const dateStr = f.replace('.jsonl', '');
-          return dateStrings.has(dateStr);
-        })
-        .sort();
-
+      const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).filter((f) => {
+        const dateStr = f.replace(".jsonl", "");
+        return dateStrings.has(dateStr);
+      }).sort();
       for (const file of jsonlFiles) {
         try {
-          const content = await fs.readFile(path.join(FEEDBACK_DIR, file), 'utf8');
-          const lines = content.trim().split('\n').filter(Boolean);
+          const content = await fs.readFile(path.join(FEEDBACK_DIR, file), "utf8");
+          const lines = content.trim().split("\n").filter(Boolean);
           for (const line of lines) {
             try {
               const entry = JSON.parse(line);
-              entry._file = file;
+              entry["_file"] = file;
               entries.push(entry);
             } catch {
-              // Skip malformed lines
             }
           }
         } catch {
-          // Skip unreadable files
         }
       }
     } catch {
-      // Feedback dir doesn't exist yet
     }
-
     return entries;
   }
-
   /**
    * Aggregate feedback entries by intent category.
-   *
-   * @param {object[]} entries — Array of feedback entries
-   * @returns {Map<string, { count: number, avgScore: number, avgRating: number, patternMatchRate: number, entries: object[] }>}
    */
   aggregateByIntent(entries) {
-    const buckets = new Map();
-
-    // First pass: group executions by category
-    const executions = entries.filter(e => e.type === 'execution');
-    const ratings = entries.filter(e => e.type === 'rating');
-
-    // Index ratings by executionId for fast lookup
-    const ratingsByExecId = new Map();
+    const buckets = /* @__PURE__ */ new Map();
+    const executions = entries.filter((e) => e.type === "execution");
+    const ratings = entries.filter((e) => e.type === "rating");
+    const ratingsByExecId = /* @__PURE__ */ new Map();
     for (const r of ratings) {
+      if (!r.executionId) continue;
       if (!ratingsByExecId.has(r.executionId)) {
         ratingsByExecId.set(r.executionId, []);
       }
       ratingsByExecId.get(r.executionId).push(r);
     }
-
     for (const exec of executions) {
-      const { category } = categorizeIntent(exec.intent);
-
+      const { category } = categorizeIntent(exec.intent ?? "");
       if (!buckets.has(category)) {
         buckets.set(category, {
           count: 0,
@@ -119,57 +81,43 @@ export class FeedbackAnalyzer {
           ratingCount: 0,
           patternMatchCount: 0,
           entries: [],
-          sampleIntents: [],
+          sampleIntents: []
         });
       }
-
       const bucket = buckets.get(category);
       bucket.count++;
-      bucket.totalScore += exec.score || 0;
+      bucket.totalScore += exec.score ?? 0;
       bucket.entries.push(exec);
-
       if (exec.patternMatch) {
         bucket.patternMatchCount++;
       }
-
-      // Collect unique sample intents (up to 5)
       if (bucket.sampleIntents.length < 5 && exec.intent) {
         const intentLower = exec.intent.toLowerCase();
-        if (!bucket.sampleIntents.some(s => s.toLowerCase() === intentLower)) {
+        if (!bucket.sampleIntents.some((s) => s.toLowerCase() === intentLower)) {
           bucket.sampleIntents.push(exec.intent);
         }
       }
-
-      // Attach ratings
-      const execRatings = ratingsByExecId.get(exec.executionId) || [];
+      const execRatings = ratingsByExecId.get(exec.executionId ?? "") ?? [];
       for (const r of execRatings) {
-        bucket.totalRating += r.rating;
+        bucket.totalRating += r.rating ?? 0;
         bucket.ratingCount++;
       }
     }
-
-    // Compute averages
-    const result = new Map();
+    const result = /* @__PURE__ */ new Map();
     for (const [category, bucket] of buckets) {
       result.set(category, {
         count: bucket.count,
         avgScore: bucket.count > 0 ? Math.round(bucket.totalScore / bucket.count) : 0,
-        avgRating: bucket.ratingCount > 0 ? Math.round((bucket.totalRating / bucket.ratingCount) * 10) / 10 : 0,
-        patternMatchRate: bucket.count > 0 ? Math.round((bucket.patternMatchCount / bucket.count) * 100) : 0,
+        avgRating: bucket.ratingCount > 0 ? Math.round(bucket.totalRating / bucket.ratingCount * 10) / 10 : 0,
+        patternMatchRate: bucket.count > 0 ? Math.round(bucket.patternMatchCount / bucket.count * 100) : 0,
         sampleIntents: bucket.sampleIntents,
-        entries: bucket.entries,
+        entries: bucket.entries
       });
     }
-
     return result;
   }
-
   /**
    * Find intent categories with weak performance.
-   *
-   * @param {Map} aggregated — Output of aggregateByIntent
-   * @param {number} threshold — Score threshold (default 60)
-   * @returns {Array<{ category: string, count: number, avgScore: number, avgRating: number, sampleIntents: string[] }>}
    */
   findWeakIntents(aggregated, threshold = 60) {
     const weak = [];
@@ -180,19 +128,15 @@ export class FeedbackAnalyzer {
           count: data.count,
           avgScore: data.avgScore,
           avgRating: data.avgRating,
-          sampleIntents: data.sampleIntents,
+          sampleIntents: data.sampleIntents
         });
       }
     }
     return weak.sort((a, b) => a.avgScore - b.avgScore);
   }
-
   /**
    * Find intent categories ready for pattern promotion.
    * Criteria: avgScore >= 95, avgRating >= 4, count >= 3
-   *
-   * @param {Map} aggregated — Output of aggregateByIntent
-   * @returns {Array<{ category: string, count: number, avgScore: number, avgRating: number, sampleIntents: string[] }>}
    */
   findPromotionCandidates(aggregated) {
     const candidates = [];
@@ -204,18 +148,14 @@ export class FeedbackAnalyzer {
           avgScore: data.avgScore,
           avgRating: data.avgRating,
           patternMatchRate: data.patternMatchRate,
-          sampleIntents: data.sampleIntents,
+          sampleIntents: data.sampleIntents
         });
       }
     }
     return candidates.sort((a, b) => b.avgScore - a.avgScore);
   }
-
   /**
    * Find intent categories with no pattern match AND low scores — gaps in pattern coverage.
-   *
-   * @param {Map} aggregated — Output of aggregateByIntent
-   * @returns {Array<{ category: string, count: number, avgScore: number, patternMatchRate: number, sampleIntents: string[] }>}
    */
   findPatternGaps(aggregated) {
     const gaps = [];
@@ -227,10 +167,14 @@ export class FeedbackAnalyzer {
           avgScore: data.avgScore,
           avgRating: data.avgRating,
           patternMatchRate: data.patternMatchRate,
-          sampleIntents: data.sampleIntents,
+          sampleIntents: data.sampleIntents
         });
       }
     }
     return gaps.sort((a, b) => a.avgScore - b.avgScore);
   }
 }
+export {
+  FeedbackAnalyzer,
+  feedbackStore
+};

package/feedback/feedback-analyzer.ts

@@ -78,8 +78,8 @@ export class FeedbackAnalyzer {
     try {
       const files = await fs.readdir(FEEDBACK_DIR);
       const jsonlFiles = files
-        .filter(f => f.endsWith('.jsonl'))
-        .filter(f => {
+        .filter((f: string) => f.endsWith('.jsonl'))
+        .filter((f: string) => {
           const dateStr = f.replace('.jsonl', '');
           return dateStrings.has(dateStr);
         })

package/feedback/feedback-store.js

@@ -1,167 +1,148 @@
-/**
- * Persistent Feedback Store
- *
- * Writes execution metadata, ratings, LLM self-critique, and gap signals
- * to JSONL files on disk. One file per day. Browser-safe (no-ops if no fs).
- *
- * Usage:
- *   import { feedbackStore } from './feedback-store.js';
- *   feedbackStore.logExecution({ executionId, intent, model, domain, ... });
- *   feedbackStore.logRating({ executionId, rating, ... });
- *   feedbackStore.logGap({ type: 'pattern', description: '...' });
- *   const recent = await feedbackStore.readRecent(50);
- */
-
-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/feedback
-const FEEDBACK_DIR = path
-  ? path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'a2ui/corpus', 'feedback')
-  : null;
-
+const FEEDBACK_DIR = path ? path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "a2ui/corpus", "feedback") : null;
 function todayFile() {
-  const d = new Date().toISOString().slice(0, 10);
+  const d = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   return path ? path.join(FEEDBACK_DIR, `${d}.jsonl`) : null;
 }
-
 async function append(entry) {
   if (!fs || !FEEDBACK_DIR) return;
   try {
     await fs.mkdir(FEEDBACK_DIR, { recursive: true });
-    await fs.appendFile(todayFile(), JSON.stringify(entry) + '\n');
+    await fs.appendFile(todayFile(), JSON.stringify(entry) + "\n");
   } catch (e) {
-    console.warn('FeedbackStore: write failed', e.message);
+    console.warn("FeedbackStore: write failed", e.message);
   }
 }
-
-export const feedbackStore = {
-  /**
-   * Log a completed generation execution.
-   */
+const feedbackStore = {
+  /** Log a completed generation execution. */
   async logExecution({
-    executionId, intent, model, domain, mode,
-    patternMatch, patternConfidence,
-    score, componentCount, tokenCount,
-    meta, // LLM self-critique
-    messages, // A2UI output (optional — can be large)
+    executionId,
+    intent,
+    model,
+    domain,
+    mode,
+    patternMatch,
+    patternConfidence,
+    score,
+    componentCount,
+    tokenCount,
+    meta
   }) {
     await append({
-      type: 'execution',
-      timestamp: new Date().toISOString(),
-      executionId, intent, model, domain, mode,
-      patternMatch, patternConfidence,
-      score, componentCount, tokenCount,
-      meta: meta || null,
+      type: "execution",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      intent,
+      model,
+      domain,
+      mode,
+      patternMatch,
+      patternConfidence,
+      score,
+      componentCount,
+      tokenCount,
+      meta: meta ?? null
     });
   },
-
-  /**
-   * Log a user rating (👍/👎).
-   */
+  /** Log a user rating (👍/👎). */
   async logRating({ executionId, rating, intent }) {
     await append({
-      type: 'rating',
-      timestamp: new Date().toISOString(),
-      executionId, rating, intent,
+      type: "rating",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      rating,
+      intent
     });
   },
-
-  /**
-   * Log a pattern save action.
-   */
+  /** Log a pattern save action. */
   async logPatternSave({ executionId, patternName, intent }) {
     await append({
-      type: 'pattern_save',
-      timestamp: new Date().toISOString(),
-      executionId, patternName, intent,
+      type: "pattern_save",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      patternName,
+      intent
     });
   },
-
-  /**
-   * Log a training gap identified by LLM meta or heuristics.
-   */
+  /** Log a training gap identified by LLM meta or heuristics. */
   async logGap({ type, description, source, executionId }) {
     await append({
-      type: 'gap',
-      gapType: type, // 'pattern' | 'domain' | 'component' | 'prompt'
-      timestamp: new Date().toISOString(),
-      description, source, executionId,
+      type: "gap",
+      gapType: type,
+      // 'pattern' | 'domain' | 'component' | 'prompt'
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      description,
+      source,
+      executionId
     });
   },
-
-  /**
-   * Read recent feedback entries (Node only).
-   */
+  /** Read recent feedback entries (Node only). */
   async readRecent(limit = 100) {
     if (!fs || !FEEDBACK_DIR) return [];
     try {
-      const files = (await fs.readdir(FEEDBACK_DIR))
-        .filter(f => f.endsWith('.jsonl'))
-        .sort()
-        .reverse();
-
+      const files = (await fs.readdir(FEEDBACK_DIR)).filter((f) => f.endsWith(".jsonl")).sort().reverse();
       const entries = [];
       for (const file of files) {
         if (entries.length >= limit) break;
-        const content = await fs.readFile(path.join(FEEDBACK_DIR, file), 'utf8');
-        const lines = content.trim().split('\n').filter(Boolean).reverse();
+        const content = await fs.readFile(path.join(FEEDBACK_DIR, file), "utf8");
+        const lines = content.trim().split("\n").filter(Boolean).reverse();
         for (const line of lines) {
           if (entries.length >= limit) break;
-          try { entries.push(JSON.parse(line)); } catch {}
+          try {
+            entries.push(JSON.parse(line));
+          } catch {
+          }
         }
       }
       return entries;
-    } catch { return []; }
+    } catch {
+      return [];
+    }
   },
-
-  /**
-   * Get gap summary — aggregate gap signals for training improvement.
-   */
+  /** Get gap summary — aggregate gap signals for training improvement. */
   async getGapSummary() {
     const entries = await this.readRecent(500);
-    const gaps = entries.filter(e => e.type === 'gap');
+    const gaps = entries.filter((e) => e["type"] === "gap");
     const byType = {};
     for (const g of gaps) {
-      byType[g.gapType] = byType[g.gapType] || [];
-      byType[g.gapType].push(g.description);
+      if (!byType[g.gapType]) byType[g.gapType] = [];
+      byType[g.gapType].push(g.description ?? "");
     }
     return byType;
   },
-
-  /**
-   * Get quality metrics — aggregate from recent executions.
-   */
+  /** Get quality metrics — aggregate from recent executions. */
   async getQualityMetrics() {
     const entries = await this.readRecent(500);
-    const executions = entries.filter(e => e.type === 'execution');
-    const ratings = entries.filter(e => e.type === 'rating');
-
+    const executions = entries.filter((e) => e["type"] === "execution");
+    const ratings = entries.filter((e) => e["type"] === "rating");
     if (executions.length === 0) return { executions: 0, avgScore: 0, avgTokens: 0, thumbUpRate: 0 };
-
-    const avgScore = executions.reduce((s, e) => s + (e.score || 0), 0) / executions.length;
-    const avgTokens = executions.reduce((s, e) => s + (e.tokenCount || 0), 0) / executions.length;
-    const thumbsUp = ratings.filter(r => r.rating >= 4).length;
-    const thumbsDown = ratings.filter(r => r.rating < 4).length;
-    const thumbUpRate = (thumbsUp + thumbsDown) > 0 ? thumbsUp / (thumbsUp + thumbsDown) : 0;
-
-    // Per-domain breakdown
+    const avgScore = executions.reduce((s, e) => s + (e.score ?? 0), 0) / executions.length;
+    const avgTokens = executions.reduce((s, e) => s + (e.tokenCount ?? 0), 0) / executions.length;
+    const thumbsUp = ratings.filter((r) => r.rating >= 4).length;
+    const thumbsDown = ratings.filter((r) => r.rating < 4).length;
+    const thumbUpRate = thumbsUp + thumbsDown > 0 ? thumbsUp / (thumbsUp + thumbsDown) : 0;
     const byDomain = {};
     for (const e of executions) {
-      const d = e.domain || 'unknown';
+      const d = e.domain || "unknown";
       if (!byDomain[d]) byDomain[d] = { count: 0, totalScore: 0 };
       byDomain[d].count++;
-      byDomain[d].totalScore += e.score || 0;
+      byDomain[d].totalScore += e.score ?? 0;
     }
-
     return {
       executions: executions.length,
       avgScore: Math.round(avgScore),
@@ -170,7 +151,10 @@ export const feedbackStore = {
       byDomain: Object.fromEntries(
         Object.entries(byDomain).map(([d, v]) => [d, { count: v.count, avgScore: Math.round(v.totalScore / v.count) }])
       ),
-      gaps: await this.getGapSummary(),
+      gaps: await this.getGapSummary()
     };
-  },
+  }
+};
+export {
+  feedbackStore
 };

package/feedback/feedback-store.ts

@@ -155,7 +155,7 @@ export const feedbackStore = {
     if (!fs || !FEEDBACK_DIR) return [];
     try {
       const files = (await fs.readdir(FEEDBACK_DIR))
-        .filter(f => f.endsWith('.jsonl'))
+        .filter((f: string) => f.endsWith('.jsonl'))
         .sort()
         .reverse();