remem-mcp 0.6.7 → 0.7.0

package/dist/chunk-TGLOMFIE.js

@@ -0,0 +1,819 @@
+import {
+  init_engine
+} from "./chunk-ZXI67YIV.js";
+import {
+  LocalEmbedder,
+  SQLiteBackend,
+  init_local,
+  stripQueryProperNouns
+} from "./chunk-OYUNKUZK.js";
+import {
+  generateId,
+  init_ulid
+} from "./chunk-XJGDYQ34.js";
+import {
+  init_esm_shims
+} from "./chunk-ONQHLUGM.js";
+
+// src/sdk.ts
+init_esm_shims();
+init_local();
+import { createHash as createHash2 } from "crypto";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/security/redactor.ts
+init_esm_shims();
+var SECRET_PATTERNS = [
+  // OpenAI API key
+  /sk-[a-zA-Z0-9]{20,}/g,
+  // Anthropic API key
+  /sk-ant-[a-zA-Z0-9-]+/g,
+  // GitHub personal access token
+  /ghp_[a-zA-Z0-9]{36}/g,
+  // GitHub OAuth token
+  /gho_[a-zA-Z0-9]{36}/g,
+  // GitHub fine-grained token
+  /github_pat_[a-zA-Z0-9_]{82}/g,
+  // Slack token
+  /xox[baprs]-[a-zA-Z0-9-]+/g,
+  // AWS access key ID
+  /AKIA[0-9A-Z]{16}/g,
+  // AWS secret access key (40 chars, base64-ish)
+  /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40}(?![A-Za-z0-9+/])/g,
+  // PEM private key block
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  // Google API key
+  /AIza[0-9A-Za-z\-_]{35}/g,
+  // Generic bearer token (require 20+ char token to avoid redacting "Bearer with JWT")
+  /Bearer\s+[a-zA-Z0-9\-._~+/]{20,}=*/g
+];
+var MIN_LENGTH = 40;
+var ENTROPY_THRESHOLD = 4.5;
+function shannonEntropy(str) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const ch of str) {
+    freq.set(ch, (freq.get(ch) ?? 0) + 1);
+  }
+  let entropy = 0;
+  const len = str.length;
+  for (const count of freq.values()) {
+    const p = count / len;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function findHighEntropyStrings(text) {
+  const results = [];
+  const regex = /[a-zA-Z0-9+/=]{40,}/g;
+  let match;
+  match = regex.exec(text);
+  while (match !== null) {
+    const str = match[0];
+    if (str.length >= MIN_LENGTH) {
+      const entropy = shannonEntropy(str);
+      if (entropy >= ENTROPY_THRESHOLD) {
+        results.push(str);
+      }
+    }
+    match = regex.exec(text);
+  }
+  return results;
+}
+function redact(text) {
+  let result = text;
+  let redacted = false;
+  for (const pattern of SECRET_PATTERNS) {
+    const before = result;
+    result = result.replace(pattern, "[REDACTED]");
+    if (result !== before) redacted = true;
+  }
+  const highEntropy = findHighEntropyStrings(result);
+  for (const str of highEntropy) {
+    result = result.replace(str, "[REDACTED]");
+    redacted = true;
+  }
+  return { text: result, redacted };
+}
+
+// src/sdk.ts
+init_ulid();
+init_engine();
+
+// src/wiki/engine.ts
+init_esm_shims();
+init_ulid();
+import { createHash } from "crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join, relative, sep } from "path";
+function parseFrontmatter(content) {
+  if (!content.startsWith("---")) {
+    return { frontmatter: null, body: content };
+  }
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const frontmatter = content.slice(3, end).trim();
+  const body = content.slice(end + 4).replace(/^\n/, "");
+  return { frontmatter, body };
+}
+function extractTags(frontmatter) {
+  if (!frontmatter) return null;
+  const match = frontmatter.match(/^tags:\s*(.+)$/m);
+  if (!match) return null;
+  return match[1].replace(/[[\]]/g, "").trim();
+}
+function extractTitle(frontmatter, body, fileName) {
+  if (frontmatter) {
+    const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
+    if (titleMatch) return titleMatch[1].replace(/["']/g, "").trim();
+  }
+  const h1Match = body.match(/^#\s+(.+)$/m);
+  if (h1Match) return h1Match[1].trim();
+  return basename(fileName, extname(fileName));
+}
+function extractWikilinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  const regex = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    regex.lastIndex = 0;
+    match = regex.exec(lines[i]);
+    while (match !== null) {
+      links.push({
+        target: match[1].trim(),
+        text: (match[2] ?? match[1]).trim(),
+        line: i + 1
+      });
+      match = regex.exec(lines[i]);
+    }
+  }
+  return links;
+}
+function extractMarkdownLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  const regex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    regex.lastIndex = 0;
+    match = regex.exec(lines[i]);
+    while (match !== null) {
+      const target = match[2].trim();
+      if (!target.startsWith("http") && !target.startsWith("mailto:")) {
+        links.push({
+          target: target.replace(/\.md$/i, ""),
+          text: match[1].trim(),
+          line: i + 1
+        });
+      }
+      match = regex.exec(lines[i]);
+    }
+  }
+  return links;
+}
+function parseMarkdownFile(filePath, repoPath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".md" && ext !== ".markdown") return null;
+  let source;
+  try {
+    source = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const { frontmatter, body } = parseFrontmatter(source);
+  const title = extractTitle(frontmatter, body, filePath);
+  const tags = extractTags(frontmatter);
+  const contentHash = createHash("sha256").update(source).digest("hex");
+  const page = {
+    id: generateId(),
+    title,
+    content: body,
+    sourceFile: relPath,
+    section: null,
+    tags,
+    frontmatter,
+    contentHash
+  };
+  const wikilinks = extractWikilinks(body).map((l) => ({ ...l, type: "wikilink" }));
+  const mdlinks = extractMarkdownLinks(body).map((l) => ({ ...l, type: "markdown" }));
+  const links = [...wikilinks, ...mdlinks];
+  return { page, links };
+}
+function ingestFile(db, filePath, repoPath, teamId) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".md" && ext !== ".markdown") {
+    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "not markdown" };
+  }
+  const parsed = parseMarkdownFile(filePath, repoPath);
+  if (!parsed) {
+    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "parse failed" };
+  }
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const now = Date.now();
+  const existing = db.prepare("SELECT id FROM wiki_pages WHERE source_file = ? AND team_id IS ?").get(relPath, teamId);
+  let pageId = parsed.page.id;
+  if (existing) {
+    pageId = existing.id;
+    db.prepare(
+      "UPDATE wiki_pages SET title = ?, content = ?, tags = ?, frontmatter = ?, content_hash = ?, updated_at = ? WHERE id = ?"
+    ).run(
+      parsed.page.title,
+      parsed.page.content,
+      parsed.page.tags,
+      parsed.page.frontmatter,
+      parsed.page.contentHash,
+      now,
+      pageId
+    );
+    db.prepare("DELETE FROM wiki_links WHERE from_page_id = ?").run(pageId);
+  } else {
+    db.prepare(
+      `INSERT INTO wiki_pages (id, title, content, source_file, section, tags, frontmatter, content_hash, team_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      parsed.page.id,
+      parsed.page.title,
+      parsed.page.content,
+      parsed.page.sourceFile,
+      parsed.page.section,
+      parsed.page.tags,
+      parsed.page.frontmatter,
+      parsed.page.contentHash,
+      teamId,
+      now,
+      now
+    );
+  }
+  const linkStmt = db.prepare(
+    "INSERT INTO wiki_links (from_page_id, to_page_id, to_title, link_text, link_type, line) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (const link of parsed.links) {
+    const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(link.target, teamId);
+    linkStmt.run(pageId, target?.id ?? null, link.target, link.text, link.type, link.line);
+  }
+  return {
+    file: relPath,
+    pages: 1,
+    links: parsed.links.length,
+    skipped: false
+  };
+}
+function ingestDirectory(db, dirPath, repoPath, teamId, maxFiles = 200) {
+  const results = [];
+  const files = [];
+  const walk = (dir) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      const fullPath = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (entry.startsWith(".") || entry === "node_modules" || entry === "vendor") continue;
+        walk(fullPath);
+      } else if (stat.isFile()) {
+        const ext = extname(fullPath).toLowerCase();
+        if (ext === ".md" || ext === ".markdown") {
+          files.push(fullPath);
+        }
+      }
+    }
+  };
+  walk(dirPath);
+  for (const file of files) {
+    const result = ingestFile(db, file, repoPath, teamId);
+    results.push(result);
+  }
+  const unresolved = db.prepare("SELECT id, to_title FROM wiki_links WHERE to_page_id IS NULL").all();
+  if (unresolved.length > 0) {
+    const updateStmt = db.prepare("UPDATE wiki_links SET to_page_id = ? WHERE id = ?");
+    for (const u of unresolved) {
+      const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(u.to_title, teamId);
+      if (target) {
+        updateStmt.run(target.id, u.id);
+      }
+    }
+  }
+  return results;
+}
+function searchWiki(db, query, opts = {}) {
+  const limit = opts.limit ?? 10;
+  let sql = `
+    SELECT w.id, w.title, w.source_file, snippet(wiki_fts, 1, '<b>', '</b>', '...', 20) as snippet
+    FROM wiki_fts f
+    JOIN wiki_pages w ON w.id = f.id
+    WHERE wiki_fts MATCH ?
+  `;
+  const params = [query];
+  if (opts.teamId !== void 0) {
+    sql += " AND w.team_id IS ?";
+    params.push(opts.teamId);
+  }
+  sql += " LIMIT ?";
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    title: r.title,
+    sourceFile: r.source_file,
+    snippet: r.snippet
+  }));
+}
+function getWikiPage(db, pageId) {
+  const row = db.prepare("SELECT * FROM wiki_pages WHERE id = ?").get(pageId);
+  if (!row) return null;
+  const page = {
+    id: row.id,
+    title: row.title,
+    content: row.content,
+    sourceFile: row.source_file,
+    section: row.section,
+    tags: row.tags,
+    frontmatter: row.frontmatter,
+    contentHash: row.content_hash
+  };
+  const linkRows = db.prepare("SELECT * FROM wiki_links WHERE from_page_id = ? ORDER BY line").all(pageId);
+  const links = linkRows.map((r) => ({
+    fromPageId: r.from_page_id,
+    toPageId: r.to_page_id,
+    toTitle: r.to_title,
+    linkText: r.link_text,
+    linkType: r.link_type,
+    line: r.line
+  }));
+  const backlinkRows = db.prepare("SELECT * FROM wiki_links WHERE to_page_id = ? ORDER BY line").all(pageId);
+  const backlinks = backlinkRows.map((r) => ({
+    fromPageId: r.from_page_id,
+    toPageId: r.to_page_id,
+    toTitle: r.to_title,
+    linkText: r.link_text,
+    linkType: r.link_type,
+    line: r.line
+  }));
+  return { page, links, backlinks };
+}
+function findOutdatedPages(db, repoPath, opts = {}) {
+  const pages = db.prepare("SELECT id, title, source_file, content_hash FROM wiki_pages WHERE team_id IS ?").all(opts.teamId ?? null);
+  const outdated = [];
+  for (const page of pages) {
+    const fullPath = join(repoPath, page.source_file);
+    if (!existsSync(fullPath)) {
+      outdated.push({
+        id: page.id,
+        title: page.title,
+        sourceFile: page.source_file,
+        reason: "file deleted"
+      });
+      continue;
+    }
+    try {
+      const content = readFileSync(fullPath, "utf-8");
+      const hash = createHash("sha256").update(content).digest("hex");
+      if (hash !== page.content_hash) {
+        outdated.push({
+          id: page.id,
+          title: page.title,
+          sourceFile: page.source_file,
+          reason: "content changed"
+        });
+      }
+    } catch {
+      outdated.push({
+        id: page.id,
+        title: page.title,
+        sourceFile: page.source_file,
+        reason: "read error"
+      });
+    }
+  }
+  return outdated;
+}
+
+// src/sdk.ts
+function classifyGlobalContent(content, type) {
+  if (type !== "learning" && type !== "decision" && type !== "task") return false;
+  const projectSignals = [
+    /\b\/[a-z]/i,
+    /\b\w+\/\w+\.\w{1,5}\b/,
+    /line\s*\d+/i,
+    /\b\d{4,}\b/,
+    /\bcommit\s+[0-9a-f]{7,}/i,
+    /\bsrc\//,
+    /\bdist\//,
+    /\btests?\//
+  ];
+  for (const sig of projectSignals) {
+    if (sig.test(content)) return false;
+  }
+  const lower = content.toLowerCase();
+  const globalSignals = [
+    /\balways\s+/i,
+    /\bnever\s+/i,
+    /\brule\b/i,
+    /\bconvention\b/i,
+    /\bpattern\b/i,
+    /\bprefer\b/i,
+    /\bavoid\b/i,
+    /\bshould\b/i,
+    /\bbest\s+practice\b/i
+  ];
+  let score = 0;
+  for (const sig of globalSignals) {
+    if (sig.test(lower)) score++;
+  }
+  if (content.length < 300 && score >= 1) return true;
+  if (content.length < 150 && type === "learning") return true;
+  return false;
+}
+var Memory = class {
+  storage;
+  embedder;
+  sessionKey;
+  globalKey;
+  redactSecrets;
+  constructor(opts) {
+    const dbPath = opts?.dbPath ?? join2(homedir(), ".local", "share", "remem-mcp", "memory.db");
+    this.storage = new SQLiteBackend(dbPath);
+    this.embedder = new LocalEmbedder();
+    this.sessionKey = opts?.sessionKey ?? process.env.REMEM_SESSION_KEY ?? createHash2("sha256").update(process.cwd()).digest("hex").slice(0, 16);
+    this.globalKey = opts?.globalSessionKey ?? process.env.REMEM_GLOBAL_SESSION_KEY ?? null;
+    this.redactSecrets = opts?.redactSecrets ?? true;
+  }
+  /** Capture a memory entry. Returns the ID, or null if duplicate. */
+  async capture(content, type, tags = [], opts) {
+    const { text: redactedContent } = this.redactSecrets ? redact(content) : { text: content };
+    let sessionKey = opts?.sessionKey ?? this.sessionKey;
+    if (opts?.autoGlobal && !opts?.sessionKey && this.globalKey && this.globalKey !== sessionKey) {
+      if (classifyGlobalContent(content, type)) {
+        sessionKey = this.globalKey;
+      }
+    }
+    const contentHash = createHash2("sha256").update(redactedContent).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey,
+      agentId: "sdk",
+      type,
+      content: redactedContent,
+      tags,
+      createdAt: Date.now()
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(redactedContent);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Recall relevant memory. Searches project + global (if configured). */
+  async recall(query, opts) {
+    const limit = Math.min(opts?.limit ?? 10, 50);
+    const mode = opts?.mode ?? "hybrid";
+    const sessionKey = opts?.sessionKey ?? this.sessionKey;
+    let queryEmbedding = null;
+    if (mode === "hybrid" || mode === "vector") {
+      const stripped = stripQueryProperNouns(query);
+      queryEmbedding = await this.embedder.embed(stripped || query);
+    }
+    if (this.globalKey && !opts?.sessionKey && this.globalKey !== sessionKey) {
+      const reservedGlobal = Math.min(3, limit);
+      const projectLimit = limit - reservedGlobal;
+      const projectResults = await this.storage.search(query, queryEmbedding, {
+        sessionKey,
+        limit: projectLimit,
+        offset: 0,
+        mode
+      });
+      let globalResults = [];
+      try {
+        globalResults = await this.storage.search(query, queryEmbedding, {
+          sessionKey: this.globalKey,
+          limit: reservedGlobal,
+          offset: 0,
+          mode
+        });
+      } catch {
+      }
+      const seen = new Set(projectResults.map((r) => r.entry.id));
+      return [...projectResults, ...globalResults.filter((r) => !seen.has(r.entry.id))].slice(
+        0,
+        limit
+      );
+    }
+    return this.storage.search(query, queryEmbedding, {
+      sessionKey,
+      limit,
+      offset: 0,
+      mode
+    });
+  }
+  /** Search with filters. Searches project + global (if configured). */
+  async search(query, opts) {
+    const limit = Math.min(opts?.limit ?? 20, 100);
+    const mode = opts?.mode ?? "hybrid";
+    const sessionKey = opts?.sessionKey ?? this.sessionKey;
+    let queryEmbedding = null;
+    if (mode === "hybrid" || mode === "vector") {
+      const stripped = stripQueryProperNouns(query);
+      queryEmbedding = await this.embedder.embed(stripped || query);
+    }
+    if (this.globalKey && !opts?.sessionKey && this.globalKey !== sessionKey) {
+      const reservedGlobal = Math.min(3, limit);
+      const projectLimit = limit - reservedGlobal;
+      const projectResults = await this.storage.search(query, queryEmbedding, {
+        sessionKey,
+        limit: projectLimit,
+        offset: 0,
+        mode,
+        filters: opts?.filters
+      });
+      let globalResults = [];
+      try {
+        globalResults = await this.storage.search(query, queryEmbedding, {
+          sessionKey: this.globalKey,
+          limit: reservedGlobal,
+          offset: 0,
+          mode,
+          filters: opts?.filters
+        });
+      } catch {
+      }
+      const seen = new Set(projectResults.map((r) => r.entry.id));
+      return [...projectResults, ...globalResults.filter((r) => !seen.has(r.entry.id))].slice(
+        0,
+        limit
+      );
+    }
+    return this.storage.search(query, queryEmbedding, {
+      sessionKey,
+      limit,
+      offset: 0,
+      mode,
+      filters: opts?.filters
+    });
+  }
+  /** Compute the embedding vector for a piece of text using the configured embedder. */
+  async embed(text) {
+    return this.embedder.embed(text);
+  }
+  /** Delete a capture by ID. */
+  async forget(id) {
+    return this.storage.delete(id);
+  }
+  /** Update an existing capture's content, tags, type, or trust state. */
+  async update(id, opts) {
+    const existing = await this.storage.get(id);
+    if (!existing) return false;
+    const newContent = opts.content ?? existing.content;
+    const newTags = opts.tags ?? existing.tags;
+    const newType = opts.type ?? existing.type;
+    const newTrust = opts.verified ? "verified" : existing.trustState ?? "candidate";
+    const contentHash = createHash2("sha256").update(newContent).digest("hex");
+    const db = this.storage.getDatabase();
+    db.prepare(
+      "UPDATE captures SET content = ?, tags = ?, type = ?, trust_state = ?, content_hash = ? WHERE id = ?"
+    ).run(newContent, JSON.stringify(newTags), newType, newTrust, contentHash, id);
+    const rowid = db.prepare("SELECT rowid FROM captures WHERE id = ?").get(id)?.rowid;
+    if (rowid) {
+      db.prepare(
+        "INSERT INTO captures_fts(captures_fts, rowid, content, tags, type) VALUES('delete', ?, '', '', '')"
+      ).run(rowid);
+      db.prepare(
+        "INSERT INTO captures_fts (rowid, id, content, tags, type) VALUES (?, ?, ?, ?, ?)"
+      ).run(rowid, id, newContent, JSON.stringify(newTags), newType);
+    }
+    if (opts.content && opts.content !== existing.content) {
+      try {
+        const embedding = await this.embedder.embed(newContent);
+        await this.storage.putVector(id, embedding);
+      } catch {
+      }
+    }
+    return true;
+  }
+  /** Find and optionally merge duplicate captures by content similarity (Jaccard). */
+  async consolidate(opts) {
+    const threshold = opts.threshold ?? 0.75;
+    const confirm = opts.confirm ?? false;
+    const sessionKey = opts.sessionKey ?? this.sessionKey;
+    const db = this.storage.getDatabase();
+    let sql = "SELECT id, content, type, tags, created_at FROM captures WHERE deleted_at IS NULL";
+    const params = [];
+    if (sessionKey !== "all") {
+      sql += " AND session_key = ?";
+      params.push(sessionKey);
+    }
+    sql += " ORDER BY created_at DESC";
+    const rows = db.prepare(sql).all(...params);
+    if (rows.length < 2) return { groups: [], merged: 0 };
+    const groups = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < rows.length; i++) {
+      if (seen.has(rows[i].id)) continue;
+      const words1 = new Set(rows[i].content.toLowerCase().split(/\s+/));
+      const group = [rows[i].id];
+      for (let j = i + 1; j < rows.length; j++) {
+        if (seen.has(rows[j].id)) continue;
+        const words2 = new Set(rows[j].content.toLowerCase().split(/\s+/));
+        const intersection = [...words1].filter((w) => words2.has(w)).length;
+        const union = (/* @__PURE__ */ new Set([...words1, ...words2])).size;
+        const sim = union > 0 ? intersection / union : 0;
+        if (sim >= threshold) {
+          group.push(rows[j].id);
+          seen.add(rows[j].id);
+        }
+      }
+      if (group.length > 1) {
+        seen.add(rows[i].id);
+        groups.push({
+          ids: group,
+          similarity: threshold,
+          preview: rows[i].content.slice(0, 80).replace(/\n/g, " ")
+        });
+      }
+    }
+    if (!confirm || groups.length === 0) {
+      return { groups, merged: 0 };
+    }
+    let merged = 0;
+    const softDelete = db.prepare("UPDATE captures SET deleted_at = ? WHERE id = ?");
+    const deleteVec = db.prepare("DELETE FROM captures_vec WHERE id = ?");
+    const deleteAtoms = db.prepare("DELETE FROM atoms WHERE capture_id = ?");
+    const mergeTx = db.transaction(() => {
+      for (const g of groups) {
+        const groupRows = g.ids.map((id) => rows.find((r) => r.id === id)).filter(Boolean).sort((a, b) => a.created_at - b.created_at);
+        const dups = groupRows.slice(1);
+        for (const dup of dups) {
+          softDelete.run(Date.now(), dup.id);
+          deleteVec.run(dup.id);
+          deleteAtoms.run(dup.id);
+          merged++;
+        }
+      }
+    });
+    mergeTx();
+    return { groups, merged };
+  }
+  /** Create a handoff packet for the next agent session. */
+  async handoff(opts) {
+    const lines = [];
+    lines.push(`# Handoff: ${opts.task}`);
+    lines.push(`Status: ${opts.status}`);
+    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push("");
+    lines.push("## Progress");
+    lines.push(opts.progress);
+    lines.push("");
+    if (opts.decisions && opts.decisions.length > 0) {
+      lines.push("## Decisions");
+      for (const d of opts.decisions) lines.push(`- ${d}`);
+      lines.push("");
+    }
+    if (opts.files && opts.files.length > 0) {
+      lines.push("## Files");
+      for (const f of opts.files) lines.push(`- ${f}`);
+      lines.push("");
+    }
+    if (opts.nextSteps && opts.nextSteps.length > 0) {
+      lines.push("## Next steps");
+      opts.nextSteps.forEach((s, i) => {
+        lines.push(`${i + 1}. ${s}`);
+      });
+      lines.push("");
+    }
+    const content = lines.join("\n");
+    const dedupPayload = JSON.stringify({
+      task: opts.task,
+      status: opts.status,
+      progress: opts.progress,
+      decisions: opts.decisions ?? [],
+      files: opts.files ?? [],
+      nextSteps: opts.nextSteps ?? []
+    });
+    const contentHash = createHash2("sha256").update(dedupPayload).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey: this.sessionKey,
+      agentId: "sdk",
+      type: "task",
+      content,
+      tags: ["handoff", `status:${opts.status}`],
+      createdAt: Date.now(),
+      metadata: {
+        handoff: true,
+        task: opts.task,
+        status: opts.status,
+        progress: opts.progress,
+        decisions: opts.decisions ?? [],
+        files: opts.files ?? [],
+        nextSteps: opts.nextSteps ?? []
+      },
+      contentHash
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(content);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Record an Architecture Decision Record (ADR). */
+  async adr(opts) {
+    const lines = [];
+    lines.push(`# ADR: ${opts.title}`);
+    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push("");
+    lines.push("## Context");
+    lines.push(opts.context);
+    lines.push("");
+    lines.push("## Decision");
+    lines.push(opts.decision);
+    lines.push("");
+    const alternatives = Array.isArray(opts.alternatives) ? opts.alternatives : typeof opts.alternatives === "string" && opts.alternatives ? [opts.alternatives] : [];
+    if (alternatives.length > 0) {
+      lines.push("## Alternatives considered");
+      for (const alt of alternatives) lines.push(`- ${alt}`);
+      lines.push("");
+    }
+    if (opts.consequences) {
+      lines.push("## Consequences");
+      lines.push(opts.consequences);
+      lines.push("");
+    }
+    const content = lines.join("\n");
+    const dedupPayload = JSON.stringify({
+      title: opts.title,
+      context: opts.context,
+      decision: opts.decision,
+      alternatives,
+      consequences: opts.consequences ?? ""
+    });
+    const contentHash = createHash2("sha256").update(dedupPayload).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey: this.sessionKey,
+      agentId: "sdk",
+      type: "decision",
+      content,
+      tags: ["adr", ...opts.tags ?? []],
+      createdAt: Date.now(),
+      metadata: {
+        adr: true,
+        title: opts.title,
+        context: opts.context,
+        decision: opts.decision,
+        alternatives,
+        consequences: opts.consequences ?? ""
+      },
+      contentHash
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(content);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Close the database connection. */
+  close() {
+    this.storage.close();
+  }
+};
+
+export {
+  redact,
+  ingestFile,
+  ingestDirectory,
+  searchWiki,
+  getWikiPage,
+  findOutdatedPages,
+  classifyGlobalContent,
+  Memory
+};
+//# sourceMappingURL=chunk-TGLOMFIE.js.map