@lov3kaizen/agentsea-memory 0.5.1

package/dist/chunk-YI7RPDEV.js

@@ -0,0 +1,1215 @@
+// src/debug/Inspector.ts
+var Inspector = class {
+  store;
+  config;
+  constructor(store, config = {}) {
+    this.store = store;
+    this.config = {
+      includeEmbeddings: config.includeEmbeddings ?? false,
+      samplingRate: config.samplingRate ?? 1,
+      maxEntriesForAnalysis: config.maxEntriesForAnalysis ?? 1e4,
+      warningThresholds: {
+        lowImportance: config.warningThresholds?.lowImportance ?? 0.2,
+        highEntryCount: config.warningThresholds?.highEntryCount ?? 5e4,
+        oldAge: config.warningThresholds?.oldAge ?? 30 * 24 * 60 * 60 * 1e3,
+        // 30 days
+        ...config.warningThresholds
+      }
+    };
+  }
+  /**
+   * Get comprehensive memory statistics
+   */
+  async getStats() {
+    const { entries, total } = await this.store.query({
+      limit: this.config.maxEntriesForAnalysis
+    });
+    const now = Date.now();
+    let totalSize = 0;
+    let totalImportance = 0;
+    let totalAccessCount = 0;
+    let entriesWithEmbeddings = 0;
+    let expiredEntries = 0;
+    let oldest = null;
+    let newest = null;
+    const typeDistribution = {};
+    const namespaceDistribution = {};
+    for (const entry of entries) {
+      totalSize += entry.content.length + JSON.stringify(entry.metadata).length;
+      totalImportance += entry.importance;
+      totalAccessCount += entry.accessCount;
+      if (entry.embedding) entriesWithEmbeddings++;
+      if (entry.expiresAt && entry.expiresAt < now) expiredEntries++;
+      if (oldest === null || entry.timestamp < oldest) oldest = entry.timestamp;
+      if (newest === null || entry.timestamp > newest) newest = entry.timestamp;
+      typeDistribution[entry.type] = (typeDistribution[entry.type] ?? 0) + 1;
+      const namespace = String(entry.metadata.namespace ?? "default");
+      namespaceDistribution[namespace] = (namespaceDistribution[namespace] ?? 0) + 1;
+    }
+    return {
+      totalEntries: total,
+      totalSize,
+      avgContentLength: entries.length > 0 ? totalSize / entries.length : 0,
+      avgImportance: entries.length > 0 ? totalImportance / entries.length : 0,
+      avgAccessCount: entries.length > 0 ? totalAccessCount / entries.length : 0,
+      typeDistribution,
+      namespaceDistribution,
+      timeRange: oldest !== null ? { oldest, newest } : null,
+      entriesWithEmbeddings,
+      expiredEntries
+    };
+  }
+  /**
+   * Inspect a specific entry
+   */
+  async inspect(id) {
+    const entry = await this.store.get(id);
+    if (!entry) return null;
+    const now = Date.now();
+    const age = now - entry.timestamp;
+    const hoursOld = age / (60 * 60 * 1e3);
+    return {
+      entry,
+      analysis: {
+        contentLength: entry.content.length,
+        wordCount: entry.content.split(/\s+/).filter((w) => w.length > 0).length,
+        hasEmbedding: !!entry.embedding,
+        embeddingDimensions: entry.embedding?.length,
+        metadataKeys: Object.keys(entry.metadata),
+        age,
+        accessRate: hoursOld > 0 ? entry.accessCount / hoursOld : entry.accessCount,
+        isExpired: !!(entry.expiresAt && entry.expiresAt < now)
+      }
+    };
+  }
+  /**
+   * Get memory health report
+   */
+  async getHealthReport() {
+    const stats = await this.getStats();
+    const issues = [];
+    const recommendations = [];
+    if (stats.totalEntries > this.config.warningThresholds.highEntryCount) {
+      issues.push({
+        type: "warning",
+        message: `High entry count: ${stats.totalEntries} entries`,
+        suggestion: "Consider consolidating or archiving old memories"
+      });
+      recommendations.push("Run memory consolidation to reduce entry count");
+    }
+    if (stats.avgImportance < this.config.warningThresholds.lowImportance) {
+      issues.push({
+        type: "info",
+        message: `Low average importance: ${(stats.avgImportance * 100).toFixed(1)}%`,
+        suggestion: "Review importance scoring or prune low-importance entries"
+      });
+    }
+    if (stats.expiredEntries > 0) {
+      issues.push({
+        type: "warning",
+        message: `${stats.expiredEntries} expired entries found`,
+        affectedEntries: stats.expiredEntries,
+        suggestion: "Run cleanup to remove expired entries"
+      });
+      recommendations.push("Clean up expired entries to free storage");
+    }
+    const withoutEmbeddings = stats.totalEntries - stats.entriesWithEmbeddings;
+    if (withoutEmbeddings > stats.totalEntries * 0.3) {
+      issues.push({
+        type: "info",
+        message: `${withoutEmbeddings} entries without embeddings (${(withoutEmbeddings / stats.totalEntries * 100).toFixed(1)}%)`,
+        affectedEntries: withoutEmbeddings,
+        suggestion: "Generate embeddings for better semantic search"
+      });
+    }
+    if (stats.timeRange) {
+      const oldestAge = Date.now() - stats.timeRange.oldest;
+      if (oldestAge > this.config.warningThresholds.oldAge) {
+        issues.push({
+          type: "info",
+          message: `Oldest entry is ${Math.round(oldestAge / (24 * 60 * 60 * 1e3))} days old`,
+          suggestion: "Consider archiving or summarizing old memories"
+        });
+      }
+    }
+    const namespaceCount = Object.keys(stats.namespaceDistribution).length;
+    if (namespaceCount === 1 && stats.totalEntries > 1e3) {
+      recommendations.push("Consider using namespaces to organize memories");
+    }
+    let score = 100;
+    for (const issue of issues) {
+      if (issue.type === "error") score -= 20;
+      else if (issue.type === "warning") score -= 10;
+      else score -= 5;
+    }
+    score = Math.max(0, Math.min(100, score));
+    return {
+      score,
+      issues,
+      recommendations
+    };
+  }
+  /**
+   * Find duplicate entries
+   */
+  async findDuplicates(threshold = 0.95) {
+    const { entries } = await this.store.query({
+      limit: this.config.maxEntriesForAnalysis
+    });
+    const duplicates = [];
+    for (let i = 0; i < entries.length; i++) {
+      for (let j = i + 1; j < entries.length; j++) {
+        const similarity = this.calculateSimilarity(entries[i], entries[j]);
+        if (similarity >= threshold) {
+          duplicates.push([entries[i], entries[j]]);
+        }
+      }
+    }
+    return duplicates;
+  }
+  /**
+   * Find orphaned entries (no parent, but has parentId)
+   */
+  async findOrphans() {
+    const { entries } = await this.store.query({
+      limit: this.config.maxEntriesForAnalysis
+    });
+    const entryIds = new Set(entries.map((e) => e.id));
+    const orphans = [];
+    for (const entry of entries) {
+      if (entry.parentId && !entryIds.has(entry.parentId)) {
+        orphans.push(entry);
+      }
+    }
+    return orphans;
+  }
+  /**
+   * Find low-value entries
+   */
+  async findLowValueEntries(options) {
+    const { entries } = await this.store.query({
+      limit: this.config.maxEntriesForAnalysis
+    });
+    const now = Date.now();
+    const maxImportance = options?.maxImportance ?? 0.2;
+    const maxAccessCount = options?.maxAccessCount ?? 2;
+    const minAge = options?.minAge ?? 7 * 24 * 60 * 60 * 1e3;
+    return entries.filter((entry) => {
+      const age = now - entry.timestamp;
+      return entry.importance <= maxImportance && entry.accessCount <= maxAccessCount && age >= minAge;
+    });
+  }
+  /**
+   * Get entry distribution over time
+   */
+  async getTimeDistribution(bucketSize = "day") {
+    const { entries } = await this.store.query({
+      limit: this.config.maxEntriesForAnalysis
+    });
+    const distribution = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const date = new Date(entry.timestamp);
+      let key;
+      switch (bucketSize) {
+        case "hour":
+          key = `${date.toISOString().slice(0, 13)}:00`;
+          break;
+        case "day":
+          key = date.toISOString().slice(0, 10);
+          break;
+        case "week": {
+          const weekStart = new Date(date);
+          weekStart.setDate(date.getDate() - date.getDay());
+          key = `week-${weekStart.toISOString().slice(0, 10)}`;
+          break;
+        }
+        case "month":
+          key = date.toISOString().slice(0, 7);
+          break;
+      }
+      distribution.set(key, (distribution.get(key) ?? 0) + 1);
+    }
+    return distribution;
+  }
+  /**
+   * Calculate similarity between two entries
+   */
+  calculateSimilarity(a, b) {
+    if (a.embedding && b.embedding) {
+      return this.cosineSimilarity(a.embedding, b.embedding);
+    }
+    return this.textSimilarity(a.content, b.content);
+  }
+  /**
+   * Cosine similarity
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+  }
+  /**
+   * Text similarity (Jaccard)
+   */
+  textSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    const intersection = new Set([...wordsA].filter((x) => wordsB.has(x)));
+    const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+    return intersection.size / union.size;
+  }
+};
+function createInspector(store, config) {
+  return new Inspector(store, config);
+}
+
+// src/debug/Timeline.ts
+var Timeline = class {
+  store;
+  config;
+  events = [];
+  markers = [];
+  constructor(store, config = {}) {
+    this.store = store;
+    this.config = {
+      timeRange: config.timeRange ?? { start: 0, end: Date.now() },
+      groupBy: config.groupBy ?? "day",
+      showTypes: config.showTypes ?? true,
+      showNamespaces: config.showNamespaces ?? true,
+      maxEvents: config.maxEvents ?? 1e4,
+      autoTrack: config.autoTrack ?? true,
+      segmentSize: config.segmentSize ?? "day"
+    };
+  }
+  /**
+   * Record a timeline event
+   */
+  recordEvent(event) {
+    const fullEvent = {
+      ...event,
+      id: `event-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+    };
+    this.events.push(fullEvent);
+    if (this.events.length > this.config.maxEvents) {
+      this.events = this.events.slice(-this.config.maxEvents);
+    }
+  }
+  /**
+   * Add a marker to the timeline
+   */
+  addMarker(marker) {
+    this.markers.push({
+      ...marker,
+      timestamp: marker.timestamp ?? Date.now()
+    });
+  }
+  /**
+   * Get timeline segments
+   */
+  async getSegments(startTime, endTime) {
+    const segments = [];
+    const segmentSize = this.getSegmentSizeMs();
+    const { entries } = await this.store.query({
+      startTime,
+      endTime,
+      limit: 1e4
+    });
+    const rangeEvents = this.events.filter(
+      (e) => e.timestamp >= startTime && e.timestamp <= endTime
+    );
+    let currentStart = startTime;
+    while (currentStart < endTime) {
+      const currentEnd = Math.min(currentStart + segmentSize, endTime);
+      const segmentEntries = entries.filter(
+        (e) => e.timestamp >= currentStart && e.timestamp < currentEnd
+      );
+      const segmentEvents = rangeEvents.filter(
+        (e) => e.timestamp >= currentStart && e.timestamp < currentEnd
+      );
+      if (segmentEntries.length > 0 || segmentEvents.length > 0) {
+        segments.push({
+          start: currentStart,
+          end: currentEnd,
+          entries: segmentEntries,
+          events: segmentEvents
+        });
+      }
+      currentStart = currentEnd;
+    }
+    return segments;
+  }
+  /**
+   * Get timeline for a specific entry
+   */
+  async getEntryTimeline(entryId) {
+    const entry = await this.store.get(entryId);
+    const entryEvents = this.events.filter((e) => e.entryId === entryId);
+    entryEvents.sort((a, b) => a.timestamp - b.timestamp);
+    const accessHistory = entryEvents.filter((e) => e.type === "access").map((e) => e.timestamp);
+    return {
+      entry,
+      events: entryEvents,
+      createdAt: entry?.createdAt ?? 0,
+      lastModified: entry?.updatedAt ?? 0,
+      accessHistory
+    };
+  }
+  /**
+   * Get activity heatmap data
+   */
+  async getActivityHeatmap(startTime, endTime, bucketSize = "hour") {
+    const heatmap = /* @__PURE__ */ new Map();
+    const { entries } = await this.store.query({
+      startTime,
+      endTime,
+      limit: 1e4
+    });
+    const rangeEvents = this.events.filter(
+      (e) => e.timestamp >= startTime && e.timestamp <= endTime
+    );
+    for (const entry of entries) {
+      const key = this.getBucketKey(entry.timestamp, bucketSize);
+      const existing = heatmap.get(key) ?? { entries: 0, events: 0 };
+      existing.entries++;
+      heatmap.set(key, existing);
+    }
+    for (const event of rangeEvents) {
+      const key = this.getBucketKey(event.timestamp, bucketSize);
+      const existing = heatmap.get(key) ?? { entries: 0, events: 0 };
+      existing.events++;
+      heatmap.set(key, existing);
+    }
+    return heatmap;
+  }
+  /**
+   * Get markers in time range
+   */
+  getMarkers(startTime, endTime) {
+    return this.markers.filter(
+      (m) => m.timestamp >= startTime && m.timestamp <= endTime
+    );
+  }
+  /**
+   * Get recent activity summary
+   */
+  getRecentActivity(windowMs = 24 * 60 * 60 * 1e3) {
+    const now = Date.now();
+    const startTime = now - windowMs;
+    const recentEvents = this.events.filter((e) => e.timestamp >= startTime);
+    const newEntries = recentEvents.filter((e) => e.type === "add").length;
+    const updatedEntries = recentEvents.filter(
+      (e) => e.type === "update"
+    ).length;
+    const deletedEntries = recentEvents.filter(
+      (e) => e.type === "delete"
+    ).length;
+    const totalAccesses = recentEvents.filter(
+      (e) => e.type === "access"
+    ).length;
+    const accessCounts = /* @__PURE__ */ new Map();
+    for (const event of recentEvents) {
+      if (event.type === "access") {
+        accessCounts.set(
+          event.entryId,
+          (accessCounts.get(event.entryId) ?? 0) + 1
+        );
+      }
+    }
+    const topAccessed = Array.from(accessCounts.entries()).map(([entryId, accessCount]) => ({ entryId, accessCount })).sort((a, b) => b.accessCount - a.accessCount).slice(0, 10);
+    return {
+      newEntries,
+      updatedEntries,
+      deletedEntries,
+      totalAccesses,
+      topAccessed
+    };
+  }
+  /**
+   * Get memory growth over time
+   */
+  async getGrowthChart(startTime, endTime, bucketSize = "day") {
+    const { entries } = await this.store.query({
+      startTime,
+      endTime,
+      limit: 1e5
+    });
+    entries.sort((a, b) => a.timestamp - b.timestamp);
+    const buckets = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const key = this.getBucketKey(entry.timestamp, bucketSize);
+      buckets.set(key, (buckets.get(key) ?? 0) + 1);
+    }
+    const sortedKeys = Array.from(buckets.keys()).sort();
+    let cumulative = 0;
+    const chart = [];
+    for (const key of sortedKeys) {
+      const newCount = buckets.get(key) ?? 0;
+      cumulative += newCount;
+      chart.push({
+        time: key,
+        cumulativeCount: cumulative,
+        newCount
+      });
+    }
+    return chart;
+  }
+  /**
+   * Find gaps in timeline (periods with no activity)
+   */
+  async findGaps(startTime, endTime, minGapSize = 24 * 60 * 60 * 1e3) {
+    const { entries } = await this.store.query({
+      startTime,
+      endTime,
+      limit: 1e4
+    });
+    if (entries.length < 2) return [];
+    const sorted = [...entries].sort((a, b) => a.timestamp - b.timestamp);
+    const gaps = [];
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i].timestamp - sorted[i - 1].timestamp;
+      if (gap >= minGapSize) {
+        gaps.push({
+          start: sorted[i - 1].timestamp,
+          end: sorted[i].timestamp,
+          durationMs: gap
+        });
+      }
+    }
+    return gaps;
+  }
+  /**
+   * Clear events
+   */
+  clearEvents() {
+    this.events = [];
+  }
+  /**
+   * Clear markers
+   */
+  clearMarkers() {
+    this.markers = [];
+  }
+  /**
+   * Export timeline data
+   */
+  exportData() {
+    return {
+      events: [...this.events],
+      markers: [...this.markers],
+      exportedAt: Date.now()
+    };
+  }
+  /**
+   * Import timeline data
+   */
+  importData(data) {
+    this.events.push(...data.events);
+    this.markers.push(...data.markers);
+  }
+  /**
+   * Get segment size in milliseconds
+   */
+  getSegmentSizeMs() {
+    switch (this.config.segmentSize) {
+      case "hour":
+        return 60 * 60 * 1e3;
+      case "day":
+        return 24 * 60 * 60 * 1e3;
+      case "week":
+        return 7 * 24 * 60 * 60 * 1e3;
+      default:
+        return 24 * 60 * 60 * 1e3;
+    }
+  }
+  /**
+   * Get bucket key for timestamp
+   */
+  getBucketKey(timestamp, bucketSize) {
+    const date = new Date(timestamp);
+    switch (bucketSize) {
+      case "hour":
+        return `${date.toISOString().slice(0, 13)}:00`;
+      case "day":
+        return date.toISOString().slice(0, 10);
+      case "week": {
+        const weekStart = new Date(date);
+        weekStart.setDate(date.getDate() - date.getDay());
+        return `week-${weekStart.toISOString().slice(0, 10)}`;
+      }
+      default:
+        return date.toISOString().slice(0, 10);
+    }
+  }
+};
+function createTimeline(store, config) {
+  return new Timeline(store, config);
+}
+
+// src/debug/Debugger.ts
+import { EventEmitter } from "eventemitter3";
+var Debugger = class extends EventEmitter {
+  store;
+  traces = [];
+  breakpoints = /* @__PURE__ */ new Map();
+  enabled = true;
+  maxTraces = 1e3;
+  constructor(store) {
+    super();
+    this.store = store;
+  }
+  /**
+   * Enable debugging
+   */
+  enable() {
+    this.enabled = true;
+  }
+  /**
+   * Disable debugging
+   */
+  disable() {
+    this.enabled = false;
+  }
+  /**
+   * Check if debugging is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Trace an operation
+   */
+  trace(operation, input, output, durationMs, metadata) {
+    if (!this.enabled) return;
+    const trace = {
+      id: `trace-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+      operation,
+      timestamp: Date.now(),
+      duration: durationMs,
+      input,
+      output,
+      metadata
+    };
+    this.traces.push(trace);
+    if (this.traces.length > this.maxTraces) {
+      this.traces = this.traces.slice(-this.maxTraces);
+    }
+    this.emit("trace", trace);
+  }
+  /**
+   * Wrap a function with tracing
+   */
+  wrapWithTrace(operation, fn) {
+    return (async (...args) => {
+      const startTime = Date.now();
+      try {
+        const result = await fn(...args);
+        this.trace(operation, args, result, Date.now() - startTime);
+        return result;
+      } catch (error) {
+        this.trace(
+          operation,
+          args,
+          { error: String(error) },
+          Date.now() - startTime,
+          {
+            error: true
+          }
+        );
+        throw error;
+      }
+    });
+  }
+  /**
+   * Add a breakpoint
+   */
+  addBreakpoint(condition, id) {
+    const breakpointId = id ?? `bp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    this.breakpoints.set(breakpointId, {
+      id: breakpointId,
+      condition,
+      enabled: true,
+      hitCount: 0
+    });
+    return breakpointId;
+  }
+  /**
+   * Remove a breakpoint
+   */
+  removeBreakpoint(id) {
+    return this.breakpoints.delete(id);
+  }
+  /**
+   * Enable/disable a breakpoint
+   */
+  toggleBreakpoint(id, enabled) {
+    const bp = this.breakpoints.get(id);
+    if (!bp) return false;
+    bp.enabled = enabled;
+    return true;
+  }
+  /**
+   * Check breakpoints for an entry/operation
+   */
+  checkBreakpoints(entry, operation) {
+    if (!this.enabled) return;
+    for (const bp of this.breakpoints.values()) {
+      if (!bp.enabled) continue;
+      try {
+        if (bp.condition(entry, operation)) {
+          bp.hitCount++;
+          this.emit("breakpointHit", bp, entry, operation);
+        }
+      } catch (error) {
+        this.emit("warning", `Breakpoint ${bp.id} condition error`, error);
+      }
+    }
+  }
+  /**
+   * Debug a retrieval operation
+   */
+  async debugRetrieval(query, embedFn, options) {
+    const timing = { total: 0 };
+    const filteringSteps = [];
+    const scoringDetails = [];
+    const totalStart = Date.now();
+    const embeddingStart = Date.now();
+    const embedding = await embedFn(query);
+    timing.embedding = Date.now() - embeddingStart;
+    const searchStart = Date.now();
+    const searchResults = await this.store.search(embedding, {
+      topK: options?.candidateMultiplier ? (options.limit ?? 10) * options.candidateMultiplier : 100,
+      minScore: 0
+      // Get all for debugging
+    });
+    timing.search = Date.now() - searchStart;
+    filteringSteps.push({
+      name: "initial-search",
+      inputCount: 0,
+      outputCount: searchResults.length,
+      durationMs: timing.search
+    });
+    let filtered = searchResults;
+    const filterStart = Date.now();
+    if (options?.types && options.types.length > 0) {
+      const beforeCount = filtered.length;
+      filtered = filtered.filter((r) => options.types.includes(r.entry.type));
+      filteringSteps.push({
+        name: "type-filter",
+        inputCount: beforeCount,
+        outputCount: filtered.length,
+        durationMs: 0
+      });
+    }
+    if (options?.namespace) {
+      const beforeCount = filtered.length;
+      filtered = filtered.filter(
+        (r) => r.entry.metadata.namespace === options.namespace
+      );
+      filteringSteps.push({
+        name: "namespace-filter",
+        inputCount: beforeCount,
+        outputCount: filtered.length,
+        durationMs: 0
+      });
+    }
+    if (options?.minScore !== void 0) {
+      const beforeCount = filtered.length;
+      filtered = filtered.filter((r) => r.score >= options.minScore);
+      filteringSteps.push({
+        name: "score-filter",
+        inputCount: beforeCount,
+        outputCount: filtered.length,
+        durationMs: 0
+      });
+    }
+    timing.filtering = Date.now() - filterStart;
+    for (const result of filtered.slice(0, options?.limit ?? 10)) {
+      scoringDetails.push({
+        entryId: result.entry.id,
+        scores: {
+          similarity: result.score,
+          importance: result.entry.importance,
+          recency: 1 / (1 + (Date.now() - result.entry.timestamp) / (24 * 60 * 60 * 1e3))
+        },
+        finalScore: result.score
+      });
+    }
+    timing.total = Date.now() - totalStart;
+    return {
+      query,
+      totalCandidates: searchResults.length,
+      returnedCount: Math.min(filtered.length, options?.limit ?? 10),
+      strategyUsed: "semantic",
+      filteringSteps,
+      scoringDetails,
+      timing
+    };
+  }
+  /**
+   * Get recent traces
+   */
+  getTraces(options) {
+    let traces = [...this.traces];
+    if (options?.operation) {
+      traces = traces.filter((t) => t.operation === options.operation);
+    }
+    if (options?.startTime) {
+      traces = traces.filter((t) => t.timestamp >= options.startTime);
+    }
+    if (options?.endTime) {
+      traces = traces.filter((t) => t.timestamp <= options.endTime);
+    }
+    traces.sort((a, b) => b.timestamp - a.timestamp);
+    return options?.limit ? traces.slice(0, options.limit) : traces;
+  }
+  /**
+   * Get operation statistics
+   */
+  getOperationStats() {
+    const stats = /* @__PURE__ */ new Map();
+    for (const trace of this.traces) {
+      const existing = stats.get(trace.operation) ?? {
+        count: 0,
+        totalDuration: 0,
+        maxDuration: 0,
+        minDuration: Infinity
+      };
+      existing.count++;
+      existing.totalDuration += trace.duration;
+      existing.maxDuration = Math.max(existing.maxDuration, trace.duration);
+      existing.minDuration = Math.min(existing.minDuration, trace.duration);
+      stats.set(trace.operation, existing);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [op, data] of stats) {
+      result.set(op, {
+        count: data.count,
+        avgDuration: data.totalDuration / data.count,
+        maxDuration: data.maxDuration,
+        minDuration: data.minDuration === Infinity ? 0 : data.minDuration
+      });
+    }
+    return result;
+  }
+  /**
+   * Get all breakpoints
+   */
+  getBreakpoints() {
+    return Array.from(this.breakpoints.values());
+  }
+  /**
+   * Clear traces
+   */
+  clearTraces() {
+    this.traces = [];
+  }
+  /**
+   * Clear all breakpoints
+   */
+  clearBreakpoints() {
+    this.breakpoints.clear();
+  }
+  /**
+   * Create a snapshot of current debug state
+   */
+  createSnapshot() {
+    return {
+      traces: [...this.traces],
+      breakpoints: this.getBreakpoints().map((bp) => ({
+        id: bp.id,
+        enabled: bp.enabled,
+        hitCount: bp.hitCount
+      })),
+      stats: this.getOperationStats(),
+      timestamp: Date.now()
+    };
+  }
+};
+function createDebugger(store) {
+  return new Debugger(store);
+}
+
+// src/debug/Exporter.ts
+var Exporter = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Export memories to string
+   */
+  async export(options = {}) {
+    const format = options.format ?? "json";
+    const { entries } = await this.store.query({
+      namespace: options.namespace,
+      types: options.types,
+      startTime: options.startTime,
+      endTime: options.endTime,
+      limit: 1e5
+      // High limit for export
+    });
+    let filtered = entries;
+    if (options.ids && options.ids.length > 0) {
+      const idSet = new Set(options.ids);
+      filtered = entries.filter((e) => idSet.has(e.id));
+    }
+    if (!options.includeEmbeddings) {
+      filtered = filtered.map((e) => ({ ...e, embedding: void 0 }));
+    }
+    let data;
+    switch (format) {
+      case "json":
+        data = this.toJSON(filtered, options.pretty);
+        break;
+      case "jsonl":
+        data = this.toJSONL(filtered);
+        break;
+      case "csv":
+        data = this.toCSV(filtered);
+        break;
+      default:
+        data = this.toJSON(filtered, options.pretty);
+    }
+    return {
+      data,
+      format,
+      entryCount: filtered.length,
+      exportedAt: Date.now(),
+      checksum: this.calculateChecksum(data)
+    };
+  }
+  /**
+   * Export to JSON file content
+   */
+  toJSON(entries, pretty = false) {
+    const exportData = {
+      version: "1.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entryCount: entries.length,
+      entries
+    };
+    return pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
+  }
+  /**
+   * Export to JSON Lines format
+   */
+  toJSONL(entries) {
+    return entries.map((e) => JSON.stringify(e)).join("\n");
+  }
+  /**
+   * Export to CSV format
+   */
+  toCSV(entries) {
+    const headers = [
+      "id",
+      "content",
+      "type",
+      "importance",
+      "timestamp",
+      "accessCount",
+      "createdAt",
+      "updatedAt",
+      "namespace",
+      "userId",
+      "agentId"
+    ];
+    const rows = entries.map((e) => {
+      return [
+        this.escapeCSV(e.id),
+        this.escapeCSV(e.content),
+        e.type,
+        e.importance.toString(),
+        e.timestamp.toString(),
+        e.accessCount.toString(),
+        e.createdAt.toString(),
+        e.updatedAt.toString(),
+        this.escapeCSV(String(e.metadata.namespace ?? "")),
+        this.escapeCSV(String(e.metadata.userId ?? "")),
+        this.escapeCSV(String(e.metadata.agentId ?? ""))
+      ].join(",");
+    });
+    return [headers.join(","), ...rows].join("\n");
+  }
+  /**
+   * Escape CSV value
+   */
+  escapeCSV(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+  /**
+   * Import memories from string
+   */
+  async import(data, format = "json", options) {
+    let entries;
+    switch (format) {
+      case "json":
+        entries = this.fromJSON(data);
+        break;
+      case "jsonl":
+        entries = this.fromJSONL(data);
+        break;
+      case "csv":
+        entries = this.fromCSV(data);
+        break;
+      default:
+        entries = this.fromJSON(data);
+    }
+    if (options?.validateOnly) {
+      return {
+        imported: 0,
+        skipped: 0,
+        errors: []
+      };
+    }
+    let imported = 0;
+    let skipped = 0;
+    const errors = [];
+    for (const entry of entries) {
+      try {
+        if (options?.namespace) {
+          entry.metadata.namespace = options.namespace;
+        }
+        const existing = await this.store.get(entry.id);
+        if (existing && !options?.overwrite) {
+          skipped++;
+          continue;
+        }
+        if (!this.validateEntry(entry)) {
+          errors.push({ entry, error: "Invalid entry format" });
+          continue;
+        }
+        if (existing) {
+          await this.store.update(entry.id, entry);
+        } else {
+          await this.store.add(entry);
+        }
+        imported++;
+      } catch (error) {
+        errors.push({ entry, error: String(error) });
+      }
+    }
+    return {
+      imported,
+      skipped,
+      errors
+    };
+  }
+  /**
+   * Parse JSON export
+   */
+  fromJSON(data) {
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) {
+      return parsed;
+    }
+    if (parsed.entries && Array.isArray(parsed.entries)) {
+      return parsed.entries;
+    }
+    throw new Error("Invalid JSON format");
+  }
+  /**
+   * Parse JSONL export
+   */
+  fromJSONL(data) {
+    return data.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  }
+  /**
+   * Parse CSV export
+   */
+  fromCSV(data) {
+    const lines = data.split("\n");
+    if (lines.length < 2) return [];
+    const headers = this.parseCSVLine(lines[0]);
+    const entries = [];
+    for (let i = 1; i < lines.length; i++) {
+      if (!lines[i].trim()) continue;
+      const values = this.parseCSVLine(lines[i]);
+      const obj = {};
+      headers.forEach((header, index) => {
+        obj[header] = values[index];
+      });
+      const entry = {
+        id: String(obj.id),
+        content: String(obj.content),
+        type: obj.type,
+        importance: parseFloat(String(obj.importance)) || 0.5,
+        metadata: {
+          source: "explicit",
+          confidence: 1,
+          namespace: String(obj.namespace || "default"),
+          userId: obj.userId ? String(obj.userId) : void 0,
+          agentId: obj.agentId ? String(obj.agentId) : void 0
+        },
+        timestamp: parseInt(String(obj.timestamp)) || Date.now(),
+        accessCount: parseInt(String(obj.accessCount)) || 0,
+        createdAt: parseInt(String(obj.createdAt)) || Date.now(),
+        updatedAt: parseInt(String(obj.updatedAt)) || Date.now()
+      };
+      entries.push(entry);
+    }
+    return entries;
+  }
+  /**
+   * Parse a CSV line
+   */
+  parseCSVLine(line) {
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"') {
+        if (inQuotes && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = !inQuotes;
+        }
+      } else if (char === "," && !inQuotes) {
+        result.push(current);
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    result.push(current);
+    return result;
+  }
+  /**
+   * Validate entry
+   */
+  validateEntry(entry) {
+    if (!entry.id || typeof entry.id !== "string") return false;
+    if (!entry.content || typeof entry.content !== "string") return false;
+    if (!entry.type) return false;
+    if (typeof entry.importance !== "number") return false;
+    if (typeof entry.timestamp !== "number") return false;
+    return true;
+  }
+  /**
+   * Calculate simple checksum
+   */
+  calculateChecksum(data) {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  /**
+   * Create backup
+   */
+  async createBackup(name) {
+    const data = await this.export({
+      format: "json",
+      includeEmbeddings: true,
+      pretty: false
+    });
+    return {
+      name: name ?? `backup-${Date.now()}`,
+      data,
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Restore from backup
+   */
+  async restoreBackup(backup, options) {
+    if (options?.clearExisting) {
+      await this.store.clear();
+    }
+    return this.import(backup.data.data, backup.data.format, {
+      overwrite: true
+    });
+  }
+  /**
+   * Get export size estimate
+   */
+  async estimateExportSize(options) {
+    const { entries, total } = await this.store.query({
+      namespace: options?.namespace,
+      types: options?.types,
+      limit: 100
+      // Sample
+    });
+    if (entries.length === 0) {
+      return {
+        entryCount: total,
+        estimatedSizeBytes: 0
+      };
+    }
+    let totalSize = 0;
+    let totalSizeWithEmbeddings = 0;
+    for (const entry of entries) {
+      const withoutEmbed = {
+        ...entry,
+        embedding: void 0
+      };
+      totalSize += JSON.stringify(withoutEmbed).length;
+      totalSizeWithEmbeddings += JSON.stringify(entry).length;
+    }
+    const avgSize = totalSize / entries.length;
+    const avgSizeWithEmbed = totalSizeWithEmbeddings / entries.length;
+    return {
+      entryCount: total,
+      estimatedSizeBytes: Math.round(avgSize * total),
+      withEmbeddingsBytes: Math.round(avgSizeWithEmbed * total)
+    };
+  }
+  /**
+   * Diff two exports
+   */
+  diffExports(export1, export2) {
+    const entries1 = this.fromJSON(export1.data);
+    const entries2 = this.fromJSON(export2.data);
+    const map1 = new Map(entries1.map((e) => [e.id, e]));
+    const map2 = new Map(entries2.map((e) => [e.id, e]));
+    const added = [];
+    const removed = [];
+    const modified = [];
+    const unchanged = [];
+    for (const [id, entry2] of map2) {
+      const entry1 = map1.get(id);
+      if (!entry1) {
+        added.push(id);
+      } else if (JSON.stringify(entry1) !== JSON.stringify(entry2)) {
+        modified.push(id);
+      } else {
+        unchanged.push(id);
+      }
+    }
+    for (const id of map1.keys()) {
+      if (!map2.has(id)) {
+        removed.push(id);
+      }
+    }
+    return { added, removed, modified, unchanged };
+  }
+};
+function createExporter(store) {
+  return new Exporter(store);
+}
+
+export {
+  Inspector,
+  createInspector,
+  Timeline,
+  createTimeline,
+  Debugger,
+  createDebugger,
+  Exporter,
+  createExporter
+};