@lov3kaizen/agentsea-evaluate 0.5.0

package/dist/chunk-PAQ2TTJJ.mjs

@@ -0,0 +1,1105 @@
+// src/feedback/collectors/BaseCollector.ts
+import { nanoid } from "nanoid";
+var BaseCollector = class {
+  store;
+  autoTimestamp;
+  generateId;
+  validateInput;
+  constructor(options = {}) {
+    this.store = options.store;
+    this.autoTimestamp = options.autoTimestamp ?? true;
+    this.generateId = options.generateId ?? (() => nanoid());
+    this.validateInput = options.validateInput ?? true;
+  }
+  /**
+   * Collect feedback
+   */
+  async collect(input) {
+    if (this.validateInput) {
+      this.validate(input);
+    }
+    const entry = this.transform(input);
+    if (this.store) {
+      await this.store.save(entry);
+    }
+    return entry;
+  }
+  /**
+   * Collect multiple feedback entries
+   */
+  async collectBatch(inputs) {
+    const entries = [];
+    for (const input of inputs) {
+      if (this.validateInput) {
+        this.validate(input);
+      }
+      const entry = this.transform(input);
+      entries.push(entry);
+    }
+    if (this.store && entries.length > 0) {
+      await this.store.saveBatch(entries);
+    }
+    return entries;
+  }
+  /**
+   * Set the feedback store
+   */
+  setStore(store) {
+    this.store = store;
+  }
+  /**
+   * Get the feedback store
+   */
+  getStore() {
+    return this.store;
+  }
+};
+
+// src/feedback/collectors/ThumbsCollector.ts
+var ThumbsCollector = class extends BaseCollector {
+  allowComment;
+  requireComment;
+  constructor(options = {}) {
+    super(options);
+    this.allowComment = options.allowComment ?? true;
+    this.requireComment = options.requireComment ?? "never";
+  }
+  validate(input) {
+    if (!input.responseId) {
+      throw new Error("responseId is required");
+    }
+    if (!input.input) {
+      throw new Error("input is required");
+    }
+    if (!input.output) {
+      throw new Error("output is required");
+    }
+    if (!input.feedback) {
+      throw new Error("feedback is required");
+    }
+    if (!["up", "down"].includes(input.feedback.rating)) {
+      throw new Error('feedback.rating must be "up" or "down"');
+    }
+    if (this.requireComment === "always" && !input.feedback.comment) {
+      throw new Error("Comment is required");
+    }
+    if (this.requireComment === "on_down" && input.feedback.rating === "down" && !input.feedback.comment) {
+      throw new Error("Comment is required for negative feedback");
+    }
+  }
+  transform(input) {
+    return {
+      id: this.generateId(),
+      type: "thumbs",
+      responseId: input.responseId,
+      conversationId: input.conversationId,
+      input: input.input,
+      output: input.output,
+      rating: input.feedback.rating,
+      comment: this.allowComment ? input.feedback.comment : void 0,
+      userId: input.userId,
+      timestamp: this.autoTimestamp ? Date.now() : 0,
+      metadata: input.metadata
+    };
+  }
+};
+function createThumbsCollector(options) {
+  return new ThumbsCollector(options);
+}
+
+// src/feedback/collectors/RatingCollector.ts
+var RatingCollector = class extends BaseCollector {
+  allowComment;
+  minRating;
+  maxRating;
+  requireComment;
+  lowRatingThreshold;
+  constructor(options = {}) {
+    super(options);
+    this.allowComment = options.allowComment ?? true;
+    this.minRating = options.minRating ?? 1;
+    this.maxRating = options.maxRating ?? 5;
+    this.requireComment = options.requireComment ?? "never";
+    this.lowRatingThreshold = options.lowRatingThreshold ?? 3;
+  }
+  validate(input) {
+    if (!input.responseId) {
+      throw new Error("responseId is required");
+    }
+    if (!input.input) {
+      throw new Error("input is required");
+    }
+    if (!input.output) {
+      throw new Error("output is required");
+    }
+    if (!input.feedback) {
+      throw new Error("feedback is required");
+    }
+    const rating = input.feedback.rating;
+    if (typeof rating !== "number") {
+      throw new Error("feedback.rating must be a number");
+    }
+    if (rating < this.minRating || rating > this.maxRating) {
+      throw new Error(
+        `feedback.rating must be between ${this.minRating} and ${this.maxRating}`
+      );
+    }
+    const isLowRating = rating <= this.lowRatingThreshold;
+    const hasComment = !!input.feedback.comment?.trim();
+    if (this.requireComment === "always" && !hasComment) {
+      throw new Error("Comment is required");
+    }
+    if (this.requireComment === "on_low" && isLowRating && !hasComment) {
+      throw new Error("Comment is required for low ratings");
+    }
+  }
+  transform(input) {
+    return {
+      id: this.generateId(),
+      type: "rating",
+      responseId: input.responseId,
+      conversationId: input.conversationId,
+      input: input.input,
+      output: input.output,
+      rating: input.feedback.rating,
+      maxRating: this.maxRating,
+      comment: this.allowComment ? input.feedback.comment : void 0,
+      userId: input.userId,
+      timestamp: this.autoTimestamp ? Date.now() : 0,
+      metadata: input.metadata
+    };
+  }
+};
+function createRatingCollector(options) {
+  return new RatingCollector(options);
+}
+
+// src/feedback/collectors/PreferenceCollector.ts
+var PreferenceCollector = class extends BaseCollector {
+  allowTie;
+  requireReason;
+  requireConfidence;
+  minConfidence;
+  constructor(options = {}) {
+    super(options);
+    this.allowTie = options.allowTie ?? true;
+    this.requireReason = options.requireReason ?? false;
+    this.requireConfidence = options.requireConfidence ?? false;
+    this.minConfidence = options.minConfidence ?? 0;
+  }
+  validate(input) {
+    if (!input.input) {
+      throw new Error("input is required");
+    }
+    if (!input.responseA || !input.responseA.id || !input.responseA.content) {
+      throw new Error("responseA with id and content is required");
+    }
+    if (!input.responseB || !input.responseB.id || !input.responseB.content) {
+      throw new Error("responseB with id and content is required");
+    }
+    const validPreferences = this.allowTie ? ["A", "B", "tie"] : ["A", "B"];
+    if (!validPreferences.includes(input.preference)) {
+      throw new Error(
+        `preference must be ${this.allowTie ? '"A", "B", or "tie"' : '"A" or "B"'}`
+      );
+    }
+    if (this.requireReason && !input.reason) {
+      throw new Error("reason is required");
+    }
+    if (this.requireConfidence && input.confidence === void 0) {
+      throw new Error("confidence is required");
+    }
+    if (input.confidence !== void 0) {
+      if (input.confidence < 0 || input.confidence > 1) {
+        throw new Error("confidence must be between 0 and 1");
+      }
+      if (input.confidence < this.minConfidence) {
+        throw new Error(`confidence must be at least ${this.minConfidence}`);
+      }
+    }
+  }
+  transform(input) {
+    return {
+      id: this.generateId(),
+      type: "preference",
+      responseId: `${input.responseA.id}_vs_${input.responseB.id}`,
+      input: input.input,
+      output: input.preference === "A" ? input.responseA.content : input.responseB.content,
+      responseA: input.responseA,
+      responseB: input.responseB,
+      preference: input.preference,
+      reason: input.reason,
+      confidence: input.confidence,
+      userId: input.userId,
+      timestamp: this.autoTimestamp ? Date.now() : 0,
+      metadata: input.metadata
+    };
+  }
+};
+function createPreferenceCollector(options) {
+  return new PreferenceCollector(options);
+}
+
+// src/feedback/collectors/CorrectionCollector.ts
+var CorrectionCollector = class extends BaseCollector {
+  constructor(options = {}) {
+    super(options);
+  }
+  validate(input) {
+    if (!input.responseId) {
+      throw new Error("responseId is required");
+    }
+    if (!input.input) {
+      throw new Error("input is required");
+    }
+    if (!input.output) {
+      throw new Error("output is required");
+    }
+    if (!input.correctedOutput) {
+      throw new Error("correctedOutput is required");
+    }
+    const validTypes = ["factual", "grammar", "style", "completeness", "other"];
+    if (!validTypes.includes(input.correctionType)) {
+      throw new Error(
+        `correctionType must be one of: ${validTypes.join(", ")}`
+      );
+    }
+    if (input.output === input.correctedOutput) {
+      throw new Error("correctedOutput must be different from output");
+    }
+  }
+  transform(input) {
+    return {
+      id: this.generateId(),
+      type: "correction",
+      responseId: input.responseId,
+      conversationId: input.conversationId,
+      input: input.input,
+      output: input.output,
+      correctedOutput: input.correctedOutput,
+      correctionType: input.correctionType,
+      explanation: input.explanation,
+      userId: input.userId,
+      timestamp: this.autoTimestamp ? Date.now() : 0,
+      metadata: input.metadata
+    };
+  }
+};
+function createCorrectionCollector(options) {
+  return new CorrectionCollector(options);
+}
+
+// src/feedback/collectors/MultiCriteriaCollector.ts
+var MultiCriteriaCollector = class extends BaseCollector {
+  criteria;
+  requireAllCriteria;
+  allowCorrections;
+  constructor(options) {
+    super(options);
+    if (!options.criteria || options.criteria.length === 0) {
+      throw new Error("At least one criterion is required");
+    }
+    this.criteria = options.criteria;
+    this.requireAllCriteria = options.requireAllCriteria ?? true;
+    this.allowCorrections = options.allowCorrections ?? true;
+  }
+  validate(input) {
+    if (!input.responseId) {
+      throw new Error("responseId is required");
+    }
+    if (!input.input) {
+      throw new Error("input is required");
+    }
+    if (!input.output) {
+      throw new Error("output is required");
+    }
+    if (!input.ratings || Object.keys(input.ratings).length === 0) {
+      throw new Error("ratings is required");
+    }
+    const providedCriteria = Object.keys(input.ratings);
+    const definedCriteria = this.criteria.map((c) => c.name);
+    for (const name of providedCriteria) {
+      if (!definedCriteria.includes(name)) {
+        throw new Error(`Unknown criterion: ${name}`);
+      }
+    }
+    if (this.requireAllCriteria) {
+      for (const name of definedCriteria) {
+        if (!(name in input.ratings)) {
+          throw new Error(`Missing required criterion: ${name}`);
+        }
+      }
+    }
+    for (const [name, rating] of Object.entries(input.ratings)) {
+      const criterion = this.criteria.find((c) => c.name === name);
+      if (criterion) {
+        const [min, max] = criterion.scale;
+        if (rating < min || rating > max) {
+          throw new Error(
+            `Rating for ${name} must be between ${min} and ${max}`
+          );
+        }
+      }
+    }
+    if (input.overallRating !== void 0) {
+      if (!Number.isInteger(input.overallRating) || input.overallRating < 1 || input.overallRating > 5) {
+        throw new Error("overallRating must be an integer between 1 and 5");
+      }
+    }
+  }
+  transform(input) {
+    const criteriaRatings = [];
+    for (const [name, rating] of Object.entries(input.ratings)) {
+      const criterionRating = { name, rating };
+      if (this.allowCorrections && input.corrections?.[name]) {
+        criterionRating.correction = input.corrections[name];
+      }
+      criteriaRatings.push(criterionRating);
+    }
+    return {
+      id: this.generateId(),
+      type: "multi_criteria",
+      responseId: input.responseId,
+      conversationId: input.conversationId,
+      input: input.input,
+      output: input.output,
+      criteria: criteriaRatings,
+      overallRating: input.overallRating,
+      comment: input.comment,
+      userId: input.userId,
+      timestamp: this.autoTimestamp ? Date.now() : 0,
+      metadata: input.metadata
+    };
+  }
+  /**
+   * Get criterion definitions
+   */
+  getCriteria() {
+    return [...this.criteria];
+  }
+  /**
+   * Add a criterion
+   */
+  addCriterion(criterion) {
+    if (this.criteria.some((c) => c.name === criterion.name)) {
+      throw new Error(`Criterion ${criterion.name} already exists`);
+    }
+    this.criteria.push(criterion);
+  }
+  /**
+   * Remove a criterion
+   */
+  removeCriterion(name) {
+    const index = this.criteria.findIndex((c) => c.name === name);
+    if (index >= 0) {
+      this.criteria.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+};
+function createMultiCriteriaCollector(options) {
+  return new MultiCriteriaCollector(options);
+}
+
+// src/feedback/FeedbackStore.ts
+var MemoryFeedbackStore = class {
+  entries = /* @__PURE__ */ new Map();
+  save(entry) {
+    this.entries.set(entry.id, entry);
+    return Promise.resolve(entry.id);
+  }
+  saveBatch(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      this.entries.set(entry.id, entry);
+      ids.push(entry.id);
+    }
+    return Promise.resolve(ids);
+  }
+  get(id) {
+    return Promise.resolve(this.entries.get(id) ?? null);
+  }
+  query(options) {
+    let entries = Array.from(this.entries.values());
+    if (options.type) {
+      const types = Array.isArray(options.type) ? options.type : [options.type];
+      entries = entries.filter((e) => types.includes(e.type));
+    }
+    if (options.userId) {
+      entries = entries.filter((e) => e.userId === options.userId);
+    }
+    if (options.conversationId) {
+      entries = entries.filter(
+        (e) => e.conversationId === options.conversationId
+      );
+    }
+    if (options.responseId) {
+      entries = entries.filter((e) => e.responseId === options.responseId);
+    }
+    if (options.startTime !== void 0) {
+      entries = entries.filter((e) => e.timestamp >= options.startTime);
+    }
+    if (options.endTime !== void 0) {
+      entries = entries.filter((e) => e.timestamp <= options.endTime);
+    }
+    if (options.metadata) {
+      entries = entries.filter((e) => {
+        if (!e.metadata) return false;
+        for (const [key, value] of Object.entries(options.metadata)) {
+          if (e.metadata[key] !== value) return false;
+        }
+        return true;
+      });
+    }
+    const total = entries.length;
+    if (options.orderBy) {
+      entries.sort((a, b) => {
+        let aVal;
+        let bVal;
+        if (options.orderBy === "timestamp") {
+          aVal = a.timestamp;
+          bVal = b.timestamp;
+        } else if (options.orderBy === "rating") {
+          aVal = this.getRating(a);
+          bVal = this.getRating(b);
+        } else {
+          return 0;
+        }
+        return options.orderDir === "desc" ? bVal - aVal : aVal - bVal;
+      });
+    }
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 100;
+    entries = entries.slice(offset, offset + limit);
+    return Promise.resolve({
+      entries,
+      total,
+      hasMore: offset + entries.length < total
+    });
+  }
+  delete(id) {
+    return Promise.resolve(this.entries.delete(id));
+  }
+  clear() {
+    this.entries.clear();
+    return Promise.resolve();
+  }
+  close() {
+    return Promise.resolve();
+  }
+  getRating(entry) {
+    switch (entry.type) {
+      case "thumbs":
+        return entry.rating === "up" ? 1 : 0;
+      case "rating":
+        return entry.rating;
+      case "multi_criteria":
+        return entry.overallRating ?? 0;
+      default:
+        return 0;
+    }
+  }
+};
+var SQLiteFeedbackStore = class {
+  constructor(config) {
+    this.config = config;
+    this.tableName = config.tableName ?? "feedback";
+  }
+  db;
+  tableName;
+  initialized = false;
+  async init() {
+    if (this.initialized) return;
+    try {
+      const BetterSqlite3 = await import("better-sqlite3");
+      this.db = new BetterSqlite3.default(this.config.path);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          id TEXT PRIMARY KEY,
+          type TEXT NOT NULL,
+          response_id TEXT NOT NULL,
+          conversation_id TEXT,
+          input TEXT NOT NULL,
+          output TEXT NOT NULL,
+          user_id TEXT,
+          timestamp INTEGER NOT NULL,
+          data TEXT NOT NULL,
+          metadata TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_type ON ${this.tableName}(type);
+        CREATE INDEX IF NOT EXISTS idx_timestamp ON ${this.tableName}(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_user_id ON ${this.tableName}(user_id);
+        CREATE INDEX IF NOT EXISTS idx_response_id ON ${this.tableName}(response_id);
+      `);
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize SQLite store: ${error.message}`
+      );
+    }
+  }
+  async save(entry) {
+    await this.ensureInitialized();
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO ${this.tableName}
+      (id, type, response_id, conversation_id, input, output, user_id, timestamp, data, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      entry.id,
+      entry.type,
+      entry.responseId,
+      entry.conversationId ?? null,
+      entry.input,
+      entry.output,
+      entry.userId ?? null,
+      entry.timestamp,
+      JSON.stringify(entry),
+      entry.metadata ? JSON.stringify(entry.metadata) : null
+    );
+    return entry.id;
+  }
+  async saveBatch(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      const id = await this.save(entry);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async get(id) {
+    await this.ensureInitialized();
+    const stmt = this.db.prepare(`SELECT data FROM ${this.tableName} WHERE id = ?`);
+    const row = stmt.get(id);
+    return row ? JSON.parse(row.data) : null;
+  }
+  async query(options) {
+    await this.ensureInitialized();
+    const conditions = [];
+    const params = [];
+    if (options.type) {
+      const types = Array.isArray(options.type) ? options.type : [options.type];
+      conditions.push(`type IN (${types.map(() => "?").join(", ")})`);
+      params.push(...types);
+    }
+    if (options.userId) {
+      conditions.push("user_id = ?");
+      params.push(options.userId);
+    }
+    if (options.conversationId) {
+      conditions.push("conversation_id = ?");
+      params.push(options.conversationId);
+    }
+    if (options.responseId) {
+      conditions.push("response_id = ?");
+      params.push(options.responseId);
+    }
+    if (options.startTime !== void 0) {
+      conditions.push("timestamp >= ?");
+      params.push(options.startTime);
+    }
+    if (options.endTime !== void 0) {
+      conditions.push("timestamp <= ?");
+      params.push(options.endTime);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countStmt = this.db.prepare(`SELECT COUNT(*) as count FROM ${this.tableName} ${whereClause}`);
+    const { count: total } = countStmt.get(...params);
+    const orderBy = options.orderBy === "rating" ? "timestamp" : options.orderBy ?? "timestamp";
+    const orderDir = options.orderDir ?? "desc";
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const selectStmt = this.db.prepare(`
+      SELECT data FROM ${this.tableName}
+      ${whereClause}
+      ORDER BY ${orderBy} ${orderDir}
+      LIMIT ? OFFSET ?
+    `);
+    const rows = selectStmt.all(...params, limit, offset);
+    const entries = rows.map((row) => JSON.parse(row.data));
+    return {
+      entries,
+      total,
+      hasMore: offset + entries.length < total
+    };
+  }
+  async delete(id) {
+    await this.ensureInitialized();
+    const stmt = this.db.prepare(`DELETE FROM ${this.tableName} WHERE id = ?`);
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+  async clear() {
+    await this.ensureInitialized();
+    this.db.exec(
+      `DELETE FROM ${this.tableName}`
+    );
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+    }
+    this.initialized = false;
+    return Promise.resolve();
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+};
+function createFeedbackStore(config) {
+  switch (config.type) {
+    case "memory":
+      return new MemoryFeedbackStore();
+    case "sqlite":
+      if (!config.path) {
+        throw new Error("SQLite store requires a path");
+      }
+      return new SQLiteFeedbackStore({
+        path: config.path,
+        tableName: config.tableName
+      });
+    default:
+      throw new Error(`Unknown store type: ${config.type}`);
+  }
+}
+
+// src/feedback/FeedbackAggregator.ts
+var FeedbackAggregator = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Aggregate feedback data
+   */
+  async aggregate(options) {
+    const { entries } = await this.store.query({
+      startTime: options.timeRange?.start,
+      endTime: options.timeRange?.end,
+      ...options.filters,
+      limit: 1e5
+      // Large limit for aggregation
+    });
+    if (entries.length === 0) {
+      return [];
+    }
+    const groups = this.groupEntries(entries, options.groupBy);
+    const results = [];
+    for (const [groupKey, groupEntries] of groups) {
+      const metrics = this.calculateMetrics(groupEntries, options.metrics);
+      results.push({
+        groupKey,
+        metrics,
+        count: groupEntries.length
+      });
+    }
+    return results;
+  }
+  /**
+   * Get summary statistics
+   */
+  async getSummary(options) {
+    const { entries } = await this.store.query({
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: 1e5
+    });
+    const byType = {};
+    let thumbsUp = 0;
+    let thumbsTotal = 0;
+    let ratingSum = 0;
+    let ratingCount = 0;
+    const prefDist = { A: 0, B: 0, tie: 0 };
+    let corrections = 0;
+    for (const entry of entries) {
+      byType[entry.type] = (byType[entry.type] ?? 0) + 1;
+      switch (entry.type) {
+        case "thumbs": {
+          const thumbs = entry;
+          thumbsTotal++;
+          if (thumbs.rating === "up") thumbsUp++;
+          break;
+        }
+        case "rating": {
+          const rating = entry;
+          ratingSum += rating.rating;
+          ratingCount++;
+          break;
+        }
+        case "preference": {
+          const pref = entry;
+          prefDist[pref.preference]++;
+          break;
+        }
+        case "correction":
+          corrections++;
+          break;
+      }
+    }
+    return {
+      totalCount: entries.length,
+      byType,
+      thumbsUpRate: thumbsTotal > 0 ? thumbsUp / thumbsTotal : 0,
+      avgRating: ratingCount > 0 ? ratingSum / ratingCount : 0,
+      preferenceDistribution: prefDist,
+      correctionRate: entries.length > 0 ? corrections / entries.length : 0
+    };
+  }
+  /**
+   * Get trending metrics over time
+   */
+  async getTrends(options) {
+    const { entries } = await this.store.query({
+      startTime: options.startTime,
+      endTime: options.endTime,
+      limit: 1e5
+    });
+    const intervalMs = this.getIntervalMs(options.interval);
+    const buckets = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const bucket = Math.floor(entry.timestamp / intervalMs) * intervalMs;
+      if (!buckets.has(bucket)) {
+        buckets.set(bucket, []);
+      }
+      buckets.get(bucket).push(entry);
+    }
+    const trends = [];
+    const sortedBuckets = Array.from(buckets.entries()).sort(
+      (a, b) => a[0] - b[0]
+    );
+    for (const [timestamp, bucketEntries] of sortedBuckets) {
+      const metrics = this.calculateMetrics(bucketEntries, [options.metric]);
+      trends.push({
+        timestamp,
+        value: metrics[options.metric] ?? 0,
+        count: bucketEntries.length
+      });
+    }
+    return trends;
+  }
+  /**
+   * Group entries by field
+   */
+  groupEntries(entries, groupBy) {
+    const groups = /* @__PURE__ */ new Map();
+    if (!groupBy) {
+      groups.set("all", entries);
+      return groups;
+    }
+    for (const entry of entries) {
+      let key;
+      switch (groupBy) {
+        case "model":
+          key = entry.metadata?.model ?? "unknown";
+          break;
+        case "userId":
+          key = entry.userId ?? "anonymous";
+          break;
+        case "hour":
+          key = new Date(entry.timestamp).toISOString().slice(0, 13);
+          break;
+        case "day":
+          key = new Date(entry.timestamp).toISOString().slice(0, 10);
+          break;
+        case "week":
+          key = this.getWeekKey(entry.timestamp);
+          break;
+        case "month":
+          key = new Date(entry.timestamp).toISOString().slice(0, 7);
+          break;
+        default:
+          key = "all";
+      }
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(entry);
+    }
+    return groups;
+  }
+  /**
+   * Calculate metrics for a group of entries
+   */
+  calculateMetrics(entries, metrics) {
+    const result = {};
+    for (const metric of metrics) {
+      result[metric] = this.calculateSingleMetric(entries, metric);
+    }
+    return result;
+  }
+  /**
+   * Calculate a single metric
+   */
+  calculateSingleMetric(entries, metric) {
+    switch (metric) {
+      case "count":
+        return entries.length;
+      case "thumbsUpRate": {
+        const thumbs = entries.filter((e) => e.type === "thumbs");
+        if (thumbs.length === 0) return 0;
+        const ups = thumbs.filter((t) => t.rating === "up").length;
+        return ups / thumbs.length;
+      }
+      case "avgRating": {
+        const ratings = entries.filter((e) => e.type === "rating");
+        if (ratings.length === 0) return 0;
+        const sum = ratings.reduce((s, r) => s + r.rating, 0);
+        return sum / ratings.length;
+      }
+      case "correctionRate": {
+        if (entries.length === 0) return 0;
+        const corrections = entries.filter(
+          (e) => e.type === "correction"
+        ).length;
+        return corrections / entries.length;
+      }
+      case "preferenceWinRate": {
+        const prefs = entries.filter((e) => e.type === "preference");
+        if (prefs.length === 0) return 0;
+        const wins = prefs.filter((p) => p.preference === "A").length;
+        return wins / prefs.length;
+      }
+      case "avgCriteriaRating": {
+        const multi = entries.filter((e) => e.type === "multi_criteria");
+        if (multi.length === 0) return 0;
+        let totalRatings = 0;
+        let totalCount = 0;
+        for (const m of multi) {
+          for (const c of m.criteria) {
+            totalRatings += c.rating;
+            totalCount++;
+          }
+        }
+        return totalCount > 0 ? totalRatings / totalCount : 0;
+      }
+      default:
+        return 0;
+    }
+  }
+  /**
+   * Get week key from timestamp
+   */
+  getWeekKey(timestamp) {
+    const date = new Date(timestamp);
+    const year = date.getFullYear();
+    const week = this.getWeekNumber(date);
+    return `${year}-W${week.toString().padStart(2, "0")}`;
+  }
+  /**
+   * Get week number
+   */
+  getWeekNumber(date) {
+    const d = new Date(
+      Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
+    );
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  }
+  /**
+   * Get interval in milliseconds
+   */
+  getIntervalMs(interval) {
+    switch (interval) {
+      case "hour":
+        return 36e5;
+      case "day":
+        return 864e5;
+      case "week":
+        return 6048e5;
+    }
+  }
+};
+function createFeedbackAggregator(store) {
+  return new FeedbackAggregator(store);
+}
+
+// src/feedback/FeedbackExporter.ts
+import * as fs from "fs/promises";
+var FeedbackExporter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Export feedback to string
+   */
+  async exportToString(options) {
+    const entries = await this.getEntries(options.query);
+    const filtered = this.filterFields(
+      entries,
+      options.fields,
+      options.includeMetadata
+    );
+    switch (options.format) {
+      case "json":
+        return JSON.stringify(filtered, null, 2);
+      case "jsonl":
+        return filtered.map((e) => JSON.stringify(e)).join("\n");
+      case "csv":
+        return this.toCSV(filtered);
+      default:
+        throw new Error(`Unknown export format: ${String(options.format)}`);
+    }
+  }
+  /**
+   * Export feedback to file
+   */
+  async exportToFile(path, options) {
+    const content = await this.exportToString(options);
+    await fs.writeFile(path, content, "utf-8");
+    const entries = await this.getEntries(options.query);
+    return entries.length;
+  }
+  /**
+   * Stream export for large datasets
+   */
+  async *exportStream(options, batchSize = 1e3) {
+    let offset = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const { entries, hasMore: more } = await this.store.query({
+        ...options.query,
+        limit: batchSize,
+        offset
+      });
+      hasMore = more;
+      offset += entries.length;
+      const filtered = this.filterFields(
+        entries,
+        options.fields,
+        options.includeMetadata
+      );
+      if (options.format === "jsonl") {
+        for (const entry of filtered) {
+          yield JSON.stringify(entry) + "\n";
+        }
+      } else if (options.format === "csv") {
+        if (offset === batchSize) {
+          yield this.toCSV(filtered);
+        } else {
+          yield this.toCSVRows(filtered);
+        }
+      }
+    }
+  }
+  /**
+   * Get entries from store
+   */
+  async getEntries(query) {
+    const { entries } = await this.store.query({
+      ...query,
+      limit: query?.limit ?? 1e5
+    });
+    return entries;
+  }
+  /**
+   * Filter fields from entries
+   */
+  filterFields(entries, fields, includeMetadata = true) {
+    return entries.map((entry) => {
+      const entryRecord = entry;
+      if (fields && fields.length > 0) {
+        const filtered = {};
+        for (const field of fields) {
+          if (field in entryRecord) {
+            filtered[field] = entryRecord[field];
+          }
+        }
+        return filtered;
+      }
+      if (!includeMetadata) {
+        const { metadata: _metadata, ...rest } = entryRecord;
+        return rest;
+      }
+      return entryRecord;
+    });
+  }
+  /**
+   * Convert entries to CSV
+   */
+  toCSV(entries) {
+    if (entries.length === 0) return "";
+    const headers = this.getCSVHeaders(entries);
+    const headerRow = headers.map((h) => this.escapeCSV(h)).join(",");
+    const rows = entries.map((entry) => {
+      return headers.map((header) => {
+        const value = entry[header];
+        return this.escapeCSV(this.formatCSVValue(value));
+      }).join(",");
+    });
+    return [headerRow, ...rows].join("\n");
+  }
+  /**
+   * Convert entries to CSV rows (no header)
+   */
+  toCSVRows(entries) {
+    if (entries.length === 0) return "";
+    const headers = this.getCSVHeaders(entries);
+    return entries.map((entry) => {
+      return headers.map((header) => {
+        const value = entry[header];
+        return this.escapeCSV(this.formatCSVValue(value));
+      }).join(",");
+    }).join("\n");
+  }
+  /**
+   * Get CSV headers from entries
+   */
+  getCSVHeaders(entries) {
+    const headers = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      for (const key of Object.keys(entry)) {
+        headers.add(key);
+      }
+    }
+    return Array.from(headers);
+  }
+  /**
+   * Format value for CSV
+   */
+  formatCSVValue(value) {
+    if (value === null || value === void 0) {
+      return "";
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  /**
+   * Escape CSV value
+   */
+  escapeCSV(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+};
+function createFeedbackExporter(store) {
+  return new FeedbackExporter(store);
+}
+
+export {
+  BaseCollector,
+  ThumbsCollector,
+  createThumbsCollector,
+  RatingCollector,
+  createRatingCollector,
+  PreferenceCollector,
+  createPreferenceCollector,
+  CorrectionCollector,
+  createCorrectionCollector,
+  MultiCriteriaCollector,
+  createMultiCriteriaCollector,
+  MemoryFeedbackStore,
+  SQLiteFeedbackStore,
+  createFeedbackStore,
+  FeedbackAggregator,
+  createFeedbackAggregator,
+  FeedbackExporter,
+  createFeedbackExporter
+};