nexus-agents 2.77.13 → 2.79.0

package/dist/chunk-BJ2OMC7P.js

@@ -1,944 +0,0 @@
-import {
-  stringifyValue,
-  tokenize
-} from "./chunk-633WH2ML.js";
-import {
-  ErrorCode,
-  NexusError,
-  ValidationError,
-  createLogger,
-  err,
-  formatZodError,
-  getTimeProvider,
-  ok
-} from "./chunk-3MRM53T4.js";
-
-// src/context/memory-backend-types.ts
-import { z } from "zod";
-var MemoryImportance = {
-  LOW: "low",
-  MEDIUM: "medium",
-  HIGH: "high"
-};
-var MemoryImportanceSchema = z.enum(["low", "medium", "high"]);
-var MemoryMetadataSchema = z.object({
-  importance: MemoryImportanceSchema,
-  tags: z.array(z.string()).optional(),
-  ttl: z.number().positive().optional()
-});
-var MemoryEntrySchema = z.object({
-  key: z.string().min(1),
-  value: z.unknown(),
-  metadata: MemoryMetadataSchema,
-  createdAt: z.date(),
-  accessedAt: z.date()
-});
-var MemoryError = class extends NexusError {
-  constructor(message, options) {
-    super(message, { code: ErrorCode.INTERNAL_ERROR, ...options });
-    this.name = "MemoryError";
-  }
-};
-var HybridMemoryConfigSchema = z.object({
-  dbPath: z.string().min(1),
-  markdownDir: z.string().min(1),
-  autoExpire: z.boolean().optional()
-});
-
-// src/context/memory-backend.ts
-import { z as z2 } from "zod";
-
-// src/context/memory-markdown.ts
-import * as fs from "fs";
-import * as path from "path";
-var MemoryMarkdownHelper = class {
-  constructor(markdownDir, logger3) {
-    this.markdownDir = markdownDir;
-    this.logger = logger3;
-  }
-  /**
-   * Ensure the Markdown export directory exists.
-   */
-  ensureDir() {
-    if (!fs.existsSync(this.markdownDir)) {
-      fs.mkdirSync(this.markdownDir, { recursive: true });
-      this.logger.debug("Created Markdown directory", { path: this.markdownDir });
-    }
-  }
-  /**
-   * Write a memory entry to Markdown file.
-   */
-  async write(key, value, metadata, createdAt) {
-    const filename = this.keyToFilename(key);
-    const filepath = path.join(this.markdownDir, filename);
-    const content = this.format(key, value, metadata, createdAt);
-    try {
-      await fs.promises.writeFile(filepath, content, "utf-8");
-      this.logger.debug("Wrote Markdown file", { key, filepath });
-    } catch (error) {
-      this.logger.warn("Failed to write Markdown file", { key, filepath, error });
-    }
-  }
-  /**
-   * Delete a Markdown file for a memory.
-   */
-  delete(key) {
-    const filename = this.keyToFilename(key);
-    const filepath = path.join(this.markdownDir, filename);
-    try {
-      if (fs.existsSync(filepath)) {
-        fs.unlinkSync(filepath);
-        this.logger.debug("Deleted Markdown file", { key, filepath });
-      }
-    } catch (error) {
-      this.logger.warn("Failed to delete Markdown file", { key, filepath, error });
-    }
-  }
-  /**
-   * Convert a memory key to a safe filename.
-   */
-  keyToFilename(key) {
-    const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, "_").replace(/_+/g, "_").substring(0, 200);
-    return `${safeKey}.md`;
-  }
-  /**
-   * Format a memory entry as Markdown.
-   */
-  format(key, value, metadata, createdAt) {
-    const lines = [
-      `# Memory: ${key}`,
-      "",
-      "## Metadata",
-      "",
-      `- **Importance:** ${metadata.importance}`,
-      `- **Created:** ${createdAt.toISOString()}`
-    ];
-    if (metadata.tags !== void 0 && metadata.tags.length > 0) {
-      lines.push(`- **Tags:** ${metadata.tags.join(", ")}`);
-    }
-    if (metadata.ttl !== void 0) {
-      const expiresAt = new Date(createdAt.getTime() + metadata.ttl);
-      lines.push(`- **Expires:** ${expiresAt.toISOString()}`);
-    }
-    lines.push("", "## Value", "");
-    if (typeof value === "string") {
-      lines.push(value);
-    } else if (value === null) {
-      lines.push("`null`");
-    } else if (typeof value === "object") {
-      lines.push("```json", JSON.stringify(value, null, 2), "```");
-    } else {
-      const stringValue = typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
-      lines.push(`\`${stringValue}\``);
-    }
-    lines.push("");
-    return lines.join("\n");
-  }
-};
-
-// src/context/memory-operations.ts
-function safeParseJson(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function parseMetadataOrDefault(raw) {
-  const parsed = safeParseJson(raw);
-  if (parsed !== null && typeof parsed === "object") return parsed;
-  return { importance: "medium" };
-}
-function rowToEntry(row) {
-  return {
-    key: row.key,
-    value: safeParseJson(row.value),
-    metadata: parseMetadataOrDefault(row.metadata),
-    createdAt: new Date(row.created_at),
-    accessedAt: new Date(row.accessed_at)
-  };
-}
-function sanitizeFtsQuery(query) {
-  return query.replace(/[*:^"(){}[\]]/g, " ").replace(/\bAND\b/gi, " ").replace(/\bOR\b/gi, " ").replace(/\bNOT\b/gi, " ").replace(/\bNEAR\b/gi, " ").replace(/\s+/g, " ").trim();
-}
-function cleanupExpiredEntries(rows, database, autoExpire, logger3) {
-  const now = getTimeProvider().now();
-  const entries = [];
-  const expiredKeys = [];
-  for (const row of rows) {
-    if (autoExpire && row.expires_at !== null && row.expires_at < now) {
-      expiredKeys.push(row.key);
-      continue;
-    }
-    entries.push(rowToEntry(row));
-  }
-  if (expiredKeys.length > 0) {
-    const deleteStmt = database.prepare(
-      `DELETE FROM memories WHERE key IN (${expiredKeys.map(() => "?").join(",")})`
-    );
-    deleteStmt.run(...expiredKeys);
-    logger3.debug("Auto-expired memories", { count: expiredKeys.length });
-  }
-  return { entries, expiredCount: expiredKeys.length };
-}
-function countMemories(database) {
-  try {
-    const stmt = database.prepare("SELECT COUNT(*) as count FROM memories");
-    const row = stmt.get();
-    return ok(row?.count ?? 0);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(new MemoryError("Failed to count memories", { cause: causeError }));
-  }
-}
-function expireAllEntries(database, logger3) {
-  try {
-    const stmt = database.prepare(
-      "DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?"
-    );
-    const result = stmt.run(getTimeProvider().now());
-    logger3.info("Expired memories", { count: result.changes });
-    return ok(result.changes);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(new MemoryError("Failed to expire memories", { cause: causeError }));
-  }
-}
-function pruneOldEntries(database, olderThan, logger3) {
-  try {
-    const stmt = database.prepare("DELETE FROM memories WHERE created_at < ?");
-    const result = stmt.run(olderThan.getTime());
-    logger3.info("Pruned old memories", {
-      olderThan: olderThan.toISOString(),
-      count: result.changes
-    });
-    return ok(result.changes);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(
-      new MemoryError("Failed to prune memories", {
-        cause: causeError,
-        context: { olderThan: olderThan.toISOString() }
-      })
-    );
-  }
-}
-
-// src/context/memory-backend.ts
-var HybridMemoryBackend = class {
-  dbPath;
-  logger;
-  autoExpire;
-  markdown;
-  db = null;
-  initialized = false;
-  initPromise;
-  constructor(config) {
-    const validation = HybridMemoryConfigSchema.safeParse(config);
-    if (!validation.success) {
-      throw new ValidationError(
-        `Invalid HybridMemoryBackend config: ${formatZodError(validation.error)}`,
-        {
-          context: { config, validationErrors: validation.error.issues }
-        }
-      );
-    }
-    this.dbPath = config.dbPath;
-    this.logger = config.logger ?? createLogger({ component: "HybridMemoryBackend" });
-    this.autoExpire = config.autoExpire ?? true;
-    this.markdown = new MemoryMarkdownHelper(config.markdownDir, this.logger);
-  }
-  initializeWithDatabase(database) {
-    this.db = database;
-    this.createTables();
-    this.markdown.ensureDir();
-    this.initialized = true;
-    this.logger.info("HybridMemoryBackend initialized", { dbPath: this.dbPath });
-  }
-  async initialize() {
-    if (this.initialized) return ok(void 0);
-    this.initPromise ??= this.doInitialize().finally(() => {
-      this.initPromise = void 0;
-    });
-    return this.initPromise;
-  }
-  async doInitialize() {
-    try {
-      const betterSqlite3Module = await import("better-sqlite3").catch((cause) => {
-        this.logger.debug("better-sqlite3 import failed", { error: String(cause) });
-        return null;
-      });
-      if (betterSqlite3Module === null) {
-        return err(
-          new MemoryError("better-sqlite3 not installed. Install: npm install better-sqlite3", {
-            context: { dbPath: this.dbPath }
-          })
-        );
-      }
-      const Database = betterSqlite3Module.default;
-      this.db = new Database(this.dbPath);
-      this.createTables();
-      this.markdown.ensureDir();
-      this.initialized = true;
-      this.logger.info("HybridMemoryBackend initialized", { dbPath: this.dbPath });
-      return ok(void 0);
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to initialize HybridMemoryBackend", causeError);
-      return err(
-        new MemoryError("Failed to initialize memory backend", {
-          cause: causeError,
-          context: { dbPath: this.dbPath }
-        })
-      );
-    }
-  }
-  createTables() {
-    const database = this.getDatabase();
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        key TEXT PRIMARY KEY, value TEXT NOT NULL, metadata TEXT NOT NULL,
-        created_at INTEGER NOT NULL, accessed_at INTEGER NOT NULL, expires_at INTEGER
-      )
-    `);
-    database.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-        key, value, tags, content='memories', content_rowid='rowid'
-      )
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-        INSERT INTO memories_fts(rowid, key, value, tags)
-        SELECT rowid, NEW.key, NEW.value, json_extract(NEW.metadata, '$.tags') FROM memories WHERE key = NEW.key;
-      END
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, key, value, tags)
-        VALUES('delete', OLD.rowid, OLD.key, OLD.value, json_extract(OLD.metadata, '$.tags'));
-      END
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, key, value, tags)
-        VALUES('delete', OLD.rowid, OLD.key, OLD.value, json_extract(OLD.metadata, '$.tags'));
-        INSERT INTO memories_fts(rowid, key, value, tags)
-        SELECT rowid, NEW.key, NEW.value, json_extract(NEW.metadata, '$.tags') FROM memories WHERE key = NEW.key;
-      END
-    `);
-    database.exec(
-      `CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at) WHERE expires_at IS NOT NULL`
-    );
-    database.exec(`CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at)`);
-    this.logger.debug("Database tables created");
-  }
-  getDatabase() {
-    if (this.db === null) throw new MemoryError("Database not initialized");
-    return this.db;
-  }
-  ensureInitialized() {
-    if (!this.initialized || this.db === null) {
-      throw new MemoryError("HybridMemoryBackend not initialized. Call initialize() first.");
-    }
-  }
-  async store(key, value, metadata) {
-    try {
-      this.ensureInitialized();
-      const keyValidation = z2.string().min(1).safeParse(key);
-      if (!keyValidation.success)
-        return err(new MemoryError("Invalid key: must be non-empty string", { context: { key } }));
-      const metadataValidation = MemoryMetadataSchema.safeParse(metadata);
-      if (!metadataValidation.success)
-        return err(
-          new MemoryError("Invalid metadata", {
-            context: { metadata, errors: metadataValidation.error.issues }
-          })
-        );
-      const now = getTimeProvider().now();
-      const expiresAt = metadata.ttl !== void 0 ? now + metadata.ttl : null;
-      const database = this.getDatabase();
-      const stmt = database.prepare(
-        `INSERT OR REPLACE INTO memories (key, value, metadata, created_at, accessed_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)`
-      );
-      stmt.run(key, JSON.stringify(value), JSON.stringify(metadata), now, now, expiresAt);
-      this.logger.debug("Stored memory", { key, importance: metadata.importance });
-      if (metadata.importance === MemoryImportance.HIGH)
-        await this.markdown.write(key, value, metadata, new Date(now));
-      return ok(void 0);
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to store memory", causeError, { key });
-      return err(
-        new MemoryError("Failed to store memory", { cause: causeError, context: { key } })
-      );
-    }
-  }
-  retrieve(key) {
-    try {
-      this.ensureInitialized();
-      const database = this.getDatabase();
-      const stmt = database.prepare(
-        `SELECT key, value, metadata, created_at, accessed_at, expires_at FROM memories WHERE key = ?`
-      );
-      const row = stmt.get(key);
-      if (row === void 0) return Promise.resolve(ok(null));
-      if (this.autoExpire && row.expires_at !== null && row.expires_at < getTimeProvider().now()) {
-        database.prepare("DELETE FROM memories WHERE key = ?").run(key);
-        this.logger.debug("Auto-expired memory", { key });
-        return Promise.resolve(ok(null));
-      }
-      database.prepare("UPDATE memories SET accessed_at = ? WHERE key = ?").run(getTimeProvider().now(), key);
-      return Promise.resolve(ok(JSON.parse(row.value)));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to retrieve memory", causeError, { key });
-      return Promise.resolve(
-        err(new MemoryError("Failed to retrieve memory", { cause: causeError, context: { key } }))
-      );
-    }
-  }
-  search(query, limit) {
-    try {
-      this.ensureInitialized();
-      if (limit <= 0 || limit > 1e3)
-        return Promise.resolve(
-          err(new MemoryError("Invalid limit: must be between 1 and 1000", { context: { limit } }))
-        );
-      const sanitizedQuery = sanitizeFtsQuery(query);
-      if (sanitizedQuery.length === 0) return Promise.resolve(ok([]));
-      const database = this.getDatabase();
-      const stmt = database.prepare(`
-        SELECT m.key, m.value, m.metadata, m.created_at, m.accessed_at, m.expires_at
-        FROM memories m INNER JOIN memories_fts fts ON m.rowid = fts.rowid
-        WHERE memories_fts MATCH ? ORDER BY rank LIMIT ?
-      `);
-      const rows = stmt.all(sanitizedQuery, limit);
-      const { entries } = cleanupExpiredEntries(rows, database, this.autoExpire, this.logger);
-      return Promise.resolve(ok(entries));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to search memories", causeError, { query });
-      return Promise.resolve(
-        err(
-          new MemoryError("Failed to search memories", {
-            cause: causeError,
-            context: { query, limit }
-          })
-        )
-      );
-    }
-  }
-  prune(olderThan) {
-    this.ensureInitialized();
-    return Promise.resolve(pruneOldEntries(this.getDatabase(), olderThan, this.logger));
-  }
-  expireAll() {
-    this.ensureInitialized();
-    return Promise.resolve(expireAllEntries(this.getDatabase(), this.logger));
-  }
-  delete(key) {
-    try {
-      this.ensureInitialized();
-      const result = this.getDatabase().prepare("DELETE FROM memories WHERE key = ?").run(key);
-      if (result.changes > 0) {
-        this.markdown.delete(key);
-        this.logger.debug("Deleted memory", { key });
-        return Promise.resolve(ok(true));
-      }
-      return Promise.resolve(ok(false));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to delete memory", causeError, { key });
-      return Promise.resolve(
-        err(new MemoryError("Failed to delete memory", { cause: causeError, context: { key } }))
-      );
-    }
-  }
-  getAll(limit = 100) {
-    try {
-      this.ensureInitialized();
-      const database = this.getDatabase();
-      const rows = database.prepare(
-        `SELECT key, value, metadata, created_at, accessed_at, expires_at FROM memories ORDER BY accessed_at DESC LIMIT ?`
-      ).all(limit);
-      const { entries } = cleanupExpiredEntries(rows, database, this.autoExpire, this.logger);
-      return Promise.resolve(ok(entries));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to get all memories", causeError);
-      return Promise.resolve(
-        err(new MemoryError("Failed to get all memories", { cause: causeError }))
-      );
-    }
-  }
-  count() {
-    this.ensureInitialized();
-    return Promise.resolve(countMemories(this.getDatabase()));
-  }
-  close() {
-    if (this.db !== null) {
-      this.db.close();
-      this.db = null;
-      this.initialized = false;
-      this.logger.info("HybridMemoryBackend closed");
-    }
-  }
-};
-
-// src/context/adaptive-memory-types.ts
-import { z as z3 } from "zod";
-var ScoringWeightsBaseSchema = z3.object({
-  recency: z3.number().min(0).max(1),
-  importance: z3.number().min(0).max(1),
-  relevance: z3.number().min(0).max(1)
-});
-var ScoringWeightsSchema = ScoringWeightsBaseSchema.refine(
-  (w) => Math.abs(w.recency + w.importance + w.relevance - 1) < 1e-3,
-  { message: "Weights must sum to 1.0" }
-);
-var PartialScoringWeightsSchema = ScoringWeightsBaseSchema.partial();
-var ImportanceWeightsSchema = z3.object({
-  low: z3.number().min(0).max(1),
-  medium: z3.number().min(0).max(1),
-  high: z3.number().min(0).max(1)
-});
-var DecayConfigSchema = z3.object({
-  halfLifeMs: z3.number().positive(),
-  minScore: z3.number().min(0).max(1)
-});
-var PriorityScoreSchema = z3.object({
-  score: z3.number().min(0),
-  components: z3.object({
-    recency: z3.number().min(0).max(1),
-    importance: z3.number().min(0).max(1),
-    relevance: z3.number().min(0).max(1)
-  })
-});
-var ScoredMemoryEntrySchema = z3.object({
-  entry: z3.object({
-    key: z3.string(),
-    value: z3.unknown(),
-    metadata: z3.object({
-      importance: z3.enum(["low", "medium", "high"]),
-      tags: z3.array(z3.string()).optional(),
-      ttl: z3.number().optional()
-    }),
-    createdAt: z3.date(),
-    accessedAt: z3.date()
-  }),
-  priority: PriorityScoreSchema
-});
-var PriorityRetrievalOptionsSchema = z3.object({
-  query: z3.string().optional(),
-  limit: z3.number().int().positive().optional(),
-  minScore: z3.number().min(0).optional(),
-  weights: PartialScoringWeightsSchema.optional(),
-  importanceFilter: z3.array(z3.enum(["low", "medium", "high"])).optional(),
-  tagFilter: z3.array(z3.string()).optional()
-});
-var ScoringConfigSchema = z3.object({
-  weights: ScoringWeightsSchema,
-  importanceWeights: ImportanceWeightsSchema,
-  decay: DecayConfigSchema
-});
-var AdaptiveMemoryConfigSchema = z3.object({
-  dbPath: z3.string().min(1),
-  markdownDir: z3.string().min(1),
-  scoring: ScoringConfigSchema.partial().optional(),
-  autoExpire: z3.boolean().optional()
-});
-var DEFAULT_SCORING_WEIGHTS = {
-  recency: 0.4,
-  importance: 0.3,
-  relevance: 0.3
-};
-var DEFAULT_IMPORTANCE_WEIGHTS = {
-  low: 0.25,
-  medium: 0.5,
-  high: 1
-};
-var DEFAULT_DECAY_CONFIG = {
-  halfLifeMs: 24 * 60 * 60 * 1e3,
-  // 24 hours
-  minScore: 0.1
-};
-var DEFAULT_SCORING_CONFIG = {
-  weights: DEFAULT_SCORING_WEIGHTS,
-  importanceWeights: DEFAULT_IMPORTANCE_WEIGHTS,
-  decay: DEFAULT_DECAY_CONFIG
-};
-
-// src/utils/similarity-utils.ts
-function calculateTokenOverlap(queryTokens, targetTokens) {
-  if (queryTokens.length === 0) return 0;
-  if (targetTokens.length === 0) return 0;
-  const targetSet = new Set(targetTokens);
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (targetSet.has(token)) matches++;
-  }
-  return matches / queryTokens.length;
-}
-function calculateSetOverlapCount(sourceSet, targetSet) {
-  let count = 0;
-  for (const item of sourceSet) {
-    if (targetSet.has(item)) count++;
-  }
-  return count;
-}
-function calculateJaccardSimilarity(set1, set2) {
-  if (set1.size === 0 && set2.size === 0) return 1;
-  if (set1.size === 0 || set2.size === 0) return 0;
-  const intersection = calculateSetOverlapCount(set1, set2);
-  const union = set1.size + set2.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-function calculateTextJaccardSimilarity(text1, text2) {
-  const words1 = new Set(
-    text1.toLowerCase().split(/\s+/).filter((w) => w.length > 0)
-  );
-  const words2 = new Set(
-    text2.toLowerCase().split(/\s+/).filter((w) => w.length > 0)
-  );
-  return calculateJaccardSimilarity(words1, words2);
-}
-
-// src/utils/memory-db-utils.ts
-var logger = createLogger({ component: "MemoryDbUtils" });
-function safeJsonParse(json, fallback, context) {
-  try {
-    return JSON.parse(json);
-  } catch {
-    logger.warn("Corrupt JSON in memory database row", { context });
-    return fallback;
-  }
-}
-function memoryRowToEntry(row) {
-  return {
-    key: row.key,
-    value: safeJsonParse(row.value, row.value, `value for key="${row.key}"`),
-    metadata: safeJsonParse(
-      row.metadata,
-      { importance: MemoryImportance.MEDIUM },
-      `metadata for key="${row.key}"`
-    ),
-    createdAt: new Date(row.created_at),
-    accessedAt: new Date(row.accessed_at)
-  };
-}
-function memoryExists(db, key) {
-  const stmt = db.prepare(
-    "SELECT COUNT(*) as count FROM memories WHERE key = ?"
-  );
-  const result = stmt.get(key);
-  return result !== void 0 && result.count > 0;
-}
-function getMemoryEntry(db, key) {
-  const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
-  const row = stmt.get(key);
-  return row !== void 0 ? memoryRowToEntry(row) : void 0;
-}
-function getMemoryRow(db, key) {
-  const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
-  return stmt.get(key);
-}
-function getAllMemoryRows(db, limit) {
-  const stmt = db.prepare("SELECT * FROM memories ORDER BY accessed_at DESC LIMIT ?");
-  return stmt.all(limit);
-}
-
-// src/context/adaptive-memory-helpers.ts
-function calculateRecencyScore(accessedAt, now, halfLifeMs, minScore) {
-  const elapsedMs = now.getTime() - accessedAt.getTime();
-  if (elapsedMs <= 0) return 1;
-  const lambda = Math.LN2 / halfLifeMs;
-  const decayedScore = Math.exp(-lambda * elapsedMs);
-  return Math.max(minScore, decayedScore);
-}
-function calculateImportanceScore(importance, config) {
-  switch (importance) {
-    case MemoryImportance.HIGH:
-      return config.importanceWeights.high;
-    case MemoryImportance.MEDIUM:
-      return config.importanceWeights.medium;
-    case MemoryImportance.LOW:
-      return config.importanceWeights.low;
-    default:
-      return config.importanceWeights.medium;
-  }
-}
-function calculateRelevanceScore(query, value) {
-  if (query === void 0 || query.trim() === "") return 1;
-  const queryTokens = tokenize2(query);
-  const valueTokens = tokenize2(value);
-  if (queryTokens.length === 0 || valueTokens.length === 0) return 0.5;
-  return calculateTokenOverlap(queryTokens, valueTokens);
-}
-function tokenize2(text) {
-  return tokenize(text, 1);
-}
-function calculatePriorityScore(input) {
-  const { entry, query, now, config, weightOverrides } = input;
-  const recency = calculateRecencyScore(
-    entry.accessedAt,
-    now,
-    config.decay.halfLifeMs,
-    config.decay.minScore
-  );
-  const importance = calculateImportanceScore(entry.metadata.importance, config);
-  const relevance = calculateRelevanceScore(query, stringifyValue2(entry.value));
-  const components = { recency, importance, relevance };
-  const weights = resolveWeights(config.weights, weightOverrides);
-  const score = recency * weights.recency + importance * weights.importance + relevance * weights.relevance;
-  return { score, components };
-}
-function stringifyValue2(value) {
-  return stringifyValue(value);
-}
-function resolveWeights(base, overrides) {
-  if (overrides === void 0) return base;
-  const merged = {
-    recency: overrides.recency ?? base.recency,
-    importance: overrides.importance ?? base.importance,
-    relevance: overrides.relevance ?? base.relevance
-  };
-  const sum = merged.recency + merged.importance + merged.relevance;
-  if (sum === 0) return base;
-  if (Math.abs(sum - 1) > 1e-3) {
-    return {
-      recency: merged.recency / sum,
-      importance: merged.importance / sum,
-      relevance: merged.relevance / sum
-    };
-  }
-  return merged;
-}
-function filterScoredEntries(entries, config) {
-  return entries.filter((e) => {
-    if (config.minScore !== void 0 && e.priority.score < config.minScore) {
-      return false;
-    }
-    if (config.importanceFilter !== void 0 && config.importanceFilter.length > 0) {
-      if (!config.importanceFilter.includes(e.entry.metadata.importance)) {
-        return false;
-      }
-    }
-    if (config.tagFilter !== void 0 && config.tagFilter.length > 0) {
-      const entryTags = e.entry.metadata.tags ?? [];
-      const hasMatch = config.tagFilter.some((t) => entryTags.includes(t));
-      if (!hasMatch) return false;
-    }
-    return true;
-  });
-}
-function touchMemory(db, key) {
-  const stmt = db.prepare("UPDATE memories SET accessed_at = ? WHERE key = ?");
-  const result = stmt.run(getTimeProvider().now(), key);
-  return result.changes > 0;
-}
-function scoreAndSortEntries(rows, opts, config) {
-  const now = new Date(getTimeProvider().now());
-  const scored = rows.map((row) => {
-    const entry = memoryRowToEntry(row);
-    const priority = calculatePriorityScore({
-      entry,
-      now,
-      config,
-      ...opts?.query !== void 0 && { query: opts.query },
-      ...opts?.weights !== void 0 && { weightOverrides: opts.weights }
-    });
-    return { entry, priority };
-  });
-  const filterConfig = {
-    ...opts?.minScore !== void 0 && { minScore: opts.minScore },
-    ...opts?.importanceFilter !== void 0 && { importanceFilter: opts.importanceFilter },
-    ...opts?.tagFilter !== void 0 && { tagFilter: opts.tagFilter }
-  };
-  const filtered = filterScoredEntries(scored, filterConfig);
-  filtered.sort((a, b) => b.priority.score - a.priority.score);
-  const limit = opts?.limit ?? 100;
-  return filtered.slice(0, limit);
-}
-function mergeScoringConfig(partial) {
-  if (partial === void 0) return DEFAULT_SCORING_CONFIG;
-  return {
-    weights: partial.weights ?? DEFAULT_SCORING_CONFIG.weights,
-    importanceWeights: partial.importanceWeights ?? DEFAULT_SCORING_CONFIG.importanceWeights,
-    decay: partial.decay ?? DEFAULT_SCORING_CONFIG.decay
-  };
-}
-
-// src/context/adaptive-memory.ts
-var logger2 = createLogger({ component: "AdaptiveMemoryBackend" });
-var AdaptiveMemoryBackend = class {
-  config;
-  log;
-  base;
-  scoringConfig;
-  db = null;
-  initialized = false;
-  initPromise;
-  constructor(config) {
-    const validation = AdaptiveMemoryConfigSchema.safeParse(config);
-    if (!validation.success) {
-      const msg = validation.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      throw new MemoryError(`Invalid AdaptiveMemoryBackend config: ${msg}`);
-    }
-    this.config = config;
-    this.log = logger2;
-    this.scoringConfig = mergeScoringConfig(config.scoring);
-    this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
-  }
-  async initialize() {
-    if (this.initialized) return ok(void 0);
-    this.initPromise ??= this.doInitialize().finally(() => {
-      this.initPromise = void 0;
-    });
-    return this.initPromise;
-  }
-  async doInitialize() {
-    const baseInit = await this.base.initialize();
-    if (!baseInit.ok) return baseInit;
-    try {
-      const mod = await import("better-sqlite3").catch((cause) => {
-        this.log.debug("better-sqlite3 import failed", { error: String(cause) });
-        return null;
-      });
-      if (mod === null)
-        return err(
-          new MemoryError("better-sqlite3 not installed. Install: npm install better-sqlite3")
-        );
-      const Database = mod.default;
-      this.db = new Database(this.config.dbPath);
-      this.initialized = true;
-      this.log.info("AdaptiveMemoryBackend initialized");
-      return ok(void 0);
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return err(new MemoryError("Failed to initialize adaptive backend", { cause }));
-    }
-  }
-  initializeWithDatabase(database) {
-    this.base.initializeWithDatabase(database);
-    this.db = database;
-    this.initialized = true;
-    this.log.info("AdaptiveMemoryBackend initialized with database");
-  }
-  getDb() {
-    if (this.db === null) throw new MemoryError("Database not initialized");
-    return this.db;
-  }
-  ensureInit() {
-    if (!this.initialized) throw new MemoryError("AdaptiveMemoryBackend not initialized");
-  }
-  // =========================================================================
-  // IMemoryBackend Methods (delegated to base)
-  // =========================================================================
-  store(key, value, metadata) {
-    return this.base.store(key, value, metadata);
-  }
-  retrieve(key) {
-    return this.base.retrieve(key);
-  }
-  search(query, limit) {
-    return this.base.search(query, limit);
-  }
-  prune(olderThan) {
-    return this.base.prune(olderThan);
-  }
-  // =========================================================================
-  // IAdaptiveMemory Methods
-  // =========================================================================
-  retrieveByPriority(opts) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      const maxFetch = (opts?.limit ?? 100) * 2;
-      const rows = getAllMemoryRows(db, maxFetch);
-      const scored = scoreAndSortEntries(rows, opts, this.scoringConfig);
-      this.log.debug("Retrieved by priority", { count: scored.length, query: opts?.query });
-      return Promise.resolve(ok(scored));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to retrieve by priority", { cause })));
-    }
-  }
-  getPriorityScore(key, query) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      if (!memoryExists(db, key)) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const row = getMemoryRow(db, key);
-      if (row === void 0) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const entry = memoryRowToEntry(row);
-      const priority = calculatePriorityScore({
-        entry,
-        now: new Date(getTimeProvider().now()),
-        config: this.scoringConfig,
-        ...query !== void 0 && { query }
-      });
-      return Promise.resolve(ok(priority));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to get priority score", { cause })));
-    }
-  }
-  touch(key) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      if (!memoryExists(db, key)) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const updated = touchMemory(db, key);
-      if (!updated) {
-        return Promise.resolve(err(new MemoryError(`Failed to touch: ${key}`)));
-      }
-      this.log.debug("Touched memory", { key });
-      return Promise.resolve(ok(void 0));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to touch memory", { cause })));
-    }
-  }
-  getScoringConfig() {
-    return this.scoringConfig;
-  }
-  updateScoringConfig(config) {
-    this.scoringConfig = mergeScoringConfig({ ...this.scoringConfig, ...config });
-    this.log.info("Updated scoring config", { config: this.scoringConfig });
-  }
-  // =========================================================================
-  // Lifecycle
-  // =========================================================================
-  close() {
-    this.base.close();
-    if (this.db !== null) {
-      this.db.close();
-      this.db = null;
-    }
-    this.initialized = false;
-    this.log.info("AdaptiveMemoryBackend closed");
-  }
-};
-function createAdaptiveMemory(config) {
-  return new AdaptiveMemoryBackend(config);
-}
-
-export {
-  MemoryImportance,
-  MemoryError,
-  memoryRowToEntry,
-  memoryExists,
-  getMemoryEntry,
-  calculateTextJaccardSimilarity,
-  HybridMemoryBackend,
-  DEFAULT_SCORING_CONFIG,
-  AdaptiveMemoryBackend,
-  createAdaptiveMemory
-};
-//# sourceMappingURL=chunk-BJ2OMC7P.js.map