@really-knows-ai/foundry 2.3.2 → 3.0.0

package/dist/scripts/lib/memory/admin/create-entity-type.js

@@ -0,0 +1,43 @@
+import { memoryPaths } from '../paths.js';
+import { loadSchema, writeSchema, bumpVersion, hashFrontmatter } from '../schema.js';
+import { invalidateStore } from '../singleton.js';
+import { withLiveMemoryDb, createLiveEntityType } from './live-store.js';
+
+const IDENT = /^[a-z][a-z0-9_]*$/;
+
+function validateInputs(name, body) {
+  if (!IDENT.test(name)) throw new Error(`invalid identifier: '${name}' (expected lowercase snake_case)`);
+  if (typeof body !== 'string' || !body.trim()) throw new Error(`body must be a non-empty string`);
+}
+
+export async function createEntityType({ worktreeRoot, io, name, body }) {
+  validateInputs(name, body);
+
+  // Use relative path 'foundry' since the IO abstraction joins with worktreeRoot.
+  // worktreeRoot is used for invalidateStore() and withLiveMemoryDb() calls.
+  const foundryDir = 'foundry';
+  const p = memoryPaths(foundryDir);
+  const schema = await loadSchema(foundryDir, io);
+
+  if (schema.entities[name]) throw new Error(`entity type '${name}' already exists in schema`);
+  if (schema.edges[name]) throw new Error(`'${name}' is already declared as an edge type`);
+  if (await io.exists(p.entityTypeFile(name))) throw new Error(`entity type file already exists on disk`);
+
+  const frontmatter = { type: name };
+  const fileContent = `---\ntype: ${name}\n---\n\n${body.trim()}\n`;
+  await io.writeFile(p.entityTypeFile(name), fileContent);
+  await io.writeFile(p.relationFile(name), '');
+
+  schema.entities[name] = { frontmatterHash: hashFrontmatter(frontmatter) };
+  bumpVersion(schema);
+  await writeSchema(foundryDir, schema, io);
+
+  try {
+    await withLiveMemoryDb({ worktreeRoot, io }, async (db) => {
+      await createLiveEntityType(db, name, { embeddingsDim: schema.embeddings?.dimensions });
+    });
+  } finally {
+    invalidateStore(worktreeRoot);
+  }
+  return { type: name };
+}

package/dist/scripts/lib/memory/admin/create-extractor.js

@@ -0,0 +1,67 @@
+import { memoryPaths } from '../paths.js';
+import { loadSchema } from '../schema.js';
+
+const IDENT = /^[a-z][a-z0-9_-]*$/;
+
+function validateName(name) {
+  if (!IDENT.test(name)) throw new Error(`invalid identifier: '${name}' (expected lowercase kebab/snake)`);
+}
+
+function validateCommand(command) {
+  if (typeof command !== 'string' || !command.trim()) throw new Error(`command must be a non-empty string`);
+}
+
+function validateMemoryWrite(memoryWrite) {
+  if (!Array.isArray(memoryWrite) || memoryWrite.length === 0) {
+    throw new Error(`memoryWrite must be a non-empty array of entity type names`);
+  }
+}
+
+function validateBody(body) {
+  if (typeof body !== 'string' || !body.trim()) throw new Error(`body must be a non-empty string`);
+}
+
+async function validateSchemaTypes(foundryDir, io, memoryWrite) {
+  const schema = await loadSchema(foundryDir, io);
+  const undeclared = memoryWrite.filter((t) => !schema.entities[t]);
+  if (undeclared.length) {
+    throw new Error(`memoryWrite includes ${undeclared.join(', ')} which ${undeclared.length > 1 ? 'are' : 'is'} not declared in the project vocabulary (create entity types with add-memory-entity-type)`);
+  }
+}
+
+async function ensureExtractorsDir(p, io) {
+  if (!(await io.exists(p.extractorsDir))) {
+    await io.mkdir(p.extractorsDir, { recursive: true });
+  }
+}
+
+export async function createExtractor({ worktreeRoot, io, name, command, memoryWrite, timeout, body }) {
+  validateName(name);
+  validateCommand(command);
+  validateMemoryWrite(memoryWrite);
+  validateBody(body);
+
+  const foundryDir = 'foundry';
+  await validateSchemaTypes(foundryDir, io, memoryWrite);
+
+  const p = memoryPaths(foundryDir);
+  const path = p.extractorFile(name);
+  if (await io.exists(path)) throw new Error(`extractor already exists: ${name} (${path})`);
+
+  await ensureExtractorsDir(p, io);
+
+  const writeLine = `  write: [${memoryWrite.join(', ')}]`;
+  const timeoutLine = timeout ? `timeout: ${timeout}\n` : '';
+  const fileContent =
+    `---\n` +
+    `command: ${command}\n` +
+    `memory:\n` +
+    `${writeLine}\n` +
+    timeoutLine +
+    `---\n\n` +
+    `# ${name}\n\n` +
+    `${body.trim()}\n`;
+
+  await io.writeFile(path, fileContent);
+  return { path };
+}

package/dist/scripts/lib/memory/admin/drop-edge-type.js

@@ -0,0 +1,40 @@
+
+import { memoryPaths } from '../paths.js';
+import { loadSchema, writeSchema, bumpVersion } from '../schema.js';
+import { invalidateStore } from '../singleton.js';
+import { withLiveMemoryDb, dropLiveEdgeType } from './live-store.js';
+
+export async function dropEdgeType({ worktreeRoot, io, name, confirm }) {
+  const foundryDir = 'foundry';
+  const p = memoryPaths(foundryDir);
+  const schema = await loadSchema(foundryDir, io);
+  if (!schema.edges[name]) throw new Error(`edge type '${name}' not declared`);
+
+  if (confirm !== true) {
+    let rows = 0;
+    const relFile = p.relationFile(name);
+    if (await io.exists(relFile)) {
+      const text = await io.readFile(relFile);
+      rows = text.split('\n').filter((l) => l.trim() !== '').length;
+    }
+    return {
+      requiresConfirm: true,
+      preview: { type: 'edge', name, rows },
+    };
+  }
+
+  await io.unlink(p.edgeTypeFile(name));
+  await io.unlink(p.relationFile(name));
+  delete schema.edges[name];
+  bumpVersion(schema);
+  await writeSchema(foundryDir, schema, io);
+
+  try {
+    await withLiveMemoryDb({ worktreeRoot, io }, async (db) => {
+      await dropLiveEdgeType(db, name);
+    });
+  } finally {
+    invalidateStore(worktreeRoot);
+  }
+  return { dropped: name };
+}

package/dist/scripts/lib/memory/admin/drop-entity-type.js

@@ -0,0 +1,172 @@
+
+import { memoryPaths } from '../paths.js';
+import { loadSchema, writeSchema, bumpVersion, hashFrontmatter } from '../schema.js';
+import { parseEdgeRows, serialiseEdgeRows } from '../ndjson.js';
+import { invalidateStore } from '../singleton.js';
+import { parseFrontmatter } from '../frontmatter.js';
+import {
+  withLiveMemoryDb,
+  dropLiveEntityType,
+  dropLiveEdgeType,
+  replaceLiveEdgeRows,
+} from './live-store.js';
+import { renderEdgeFrontmatter, composeMarkdown } from './helpers.js';
+
+function adjustFmKeyValue(fm, key, name) {
+  if (fm[key] === 'any') return fm[key];
+  if (!Array.isArray(fm[key])) return fm[key];
+  const filtered = fm[key].filter((t) => t !== name);
+  return filtered.length > 0 ? filtered : fm[key];
+}
+
+function wouldCascadeForKey(fm, key, name) {
+  if (fm[key] === 'any') return false;
+  if (!Array.isArray(fm[key])) return false;
+  const filtered = fm[key].filter((t) => t !== name);
+  return filtered.length === 0 && fm[key].includes(name);
+}
+
+function computeEdgeFmAdjustment(fm, name) {
+  const nextFm = { ...fm };
+  let wouldCascade = false;
+  for (const key of ['sources', 'targets']) {
+    nextFm[key] = adjustFmKeyValue(fm, key, name);
+    if (wouldCascadeForKey(fm, key, name)) wouldCascade = true;
+  }
+  return { nextFm, wouldCascade };
+}
+
+function edgeReferencesType(fm, name) {
+  return (
+    (Array.isArray(fm.sources) && fm.sources.includes(name)) ||
+    (Array.isArray(fm.targets) && fm.targets.includes(name))
+  );
+}
+
+async function countAffectedRows(io, p, edgeName, name) {
+  const relFile = p.relationFile(edgeName);
+  if (!(await io.exists(relFile))) return 0;
+  const rows = parseEdgeRows(await io.readFile(relFile));
+  return rows.filter((r) => r.from_type === name || r.to_type === name).length;
+}
+
+async function analyseEdgeForDrop({ io, p, name, edgeName }) {
+  const edgeFile = p.edgeTypeFile(edgeName);
+  if (!(await io.exists(edgeFile))) return null;
+  const edgeText = await io.readFile(edgeFile);
+  const parsed = parseFrontmatter(edgeText, { filename: edgeFile });
+  if (!parsed.hasFrontmatter) return null;
+  const fm = parsed.frontmatter;
+
+  const { nextFm, wouldCascade } = computeEdgeFmAdjustment(fm, name);
+  if (wouldCascade) return { name: edgeName, action: 'cascadeDrop' };
+  if (!edgeReferencesType(fm, name)) return null;
+
+  const rowsAffected = await countAffectedRows(io, p, edgeName, name);
+  return { name: edgeName, action: 'prune', rowsAffected, nextFm };
+}
+
+async function analyseEntityDrop({ io, p, name, schema }) {
+  const entityRelFile = p.relationFile(name);
+  let entityRows = 0;
+  if (await io.exists(entityRelFile)) {
+    const text = await io.readFile(entityRelFile);
+    entityRows = text.split('\n').filter((l) => l.trim() !== '').length;
+  }
+
+  const affectedEdges = [];
+  for (const edgeName of Object.keys(schema.edges)) {
+    const result = await analyseEdgeForDrop({ io, p, name, edgeName });
+    if (result) affectedEdges.push(result);
+  }
+
+  return { entityRows, affectedEdges };
+}
+
+function buildPreview(analysis, name) {
+  return {
+    type: 'entity',
+    name,
+    entityRows: analysis.entityRows,
+    affectedEdges: analysis.affectedEdges.map((e) => {
+      const base = { name: e.name, action: e.action };
+      if (e.action === 'prune') base.rowsAffected = e.rowsAffected;
+      return base;
+    }),
+  };
+}
+
+async function processAffectedEdgesDisk(io, p, analysis, schema, name) {
+  for (const edge of analysis.affectedEdges) {
+    const edgeFile = p.edgeTypeFile(edge.name);
+    if (edge.action === 'cascadeDrop') {
+      await io.unlink(edgeFile);
+      await io.unlink(p.relationFile(edge.name));
+      delete schema.edges[edge.name];
+      continue;
+    }
+
+    const edgeText = await io.readFile(edgeFile);
+    const parsed = parseFrontmatter(edgeText, { filename: edgeFile });
+    const body = parsed.body;
+    const nextFm = edge.nextFm;
+    await io.writeFile(edgeFile, composeMarkdown(renderEdgeFrontmatter(nextFm), body));
+    schema.edges[edge.name].frontmatterHash = hashFrontmatter({
+      type: edge.name,
+      sources: nextFm.sources,
+      targets: nextFm.targets,
+    });
+
+    const relFile = p.relationFile(edge.name);
+    if (await io.exists(relFile)) {
+      const rows = parseEdgeRows(await io.readFile(relFile));
+      const kept = rows.filter((r) => r.from_type !== name && r.to_type !== name);
+      await io.writeFile(relFile, serialiseEdgeRows(kept));
+    }
+  }
+}
+
+async function updateLiveDb(worktreeRoot, io, p, analysis, name) {
+  await withLiveMemoryDb({ worktreeRoot, io }, async (db) => {
+    for (const edge of analysis.affectedEdges) {
+      if (edge.action === 'cascadeDrop') {
+        await dropLiveEdgeType(db, edge.name);
+        continue;
+      }
+      const relFile = p.relationFile(edge.name);
+      const rows = await io.exists(relFile)
+        ? parseEdgeRows(await io.readFile(relFile))
+        : [];
+      await replaceLiveEdgeRows(db, edge.name, rows);
+    }
+    await dropLiveEntityType(db, name);
+  });
+}
+
+export async function dropEntityType({ worktreeRoot, io, name, confirm }) {
+  const foundryDir = 'foundry';
+  const p = memoryPaths(foundryDir);
+  const schema = await loadSchema(foundryDir, io);
+  if (!schema.entities[name]) throw new Error(`entity type '${name}' not declared`);
+
+  const analysis = await analyseEntityDrop({ io, p, name, schema });
+
+  if (confirm !== true) {
+    return { requiresConfirm: true, preview: buildPreview(analysis, name) };
+  }
+
+  await io.unlink(p.entityTypeFile(name));
+  await io.unlink(p.relationFile(name));
+  await processAffectedEdgesDisk(io, p, analysis, schema, name);
+
+  delete schema.entities[name];
+  bumpVersion(schema);
+  await writeSchema(foundryDir, schema, io);
+
+  try {
+    await updateLiveDb(worktreeRoot, io, p, analysis, name);
+  } finally {
+    invalidateStore(worktreeRoot);
+  }
+  return { dropped: name };
+}

package/dist/scripts/lib/memory/admin/dump.js

@@ -0,0 +1,47 @@
+import { listEntities, getEntity, neighbours } from '../reads.js';
+
+async function dumpSingleEntity(store, vocabulary, type, name) {
+  const lines = [];
+  const ent = await getEntity(store, { type, name });
+  if (!ent) return `(no entity found: ${type}/${name})`;
+  lines.push(`# ${type}/${name}`);
+  lines.push('');
+  lines.push(ent.value);
+  lines.push('');
+  const nbrs = await neighbours(store, { type, name, depth: 1 }, vocabulary);
+  if (nbrs.edges.length > 0) {
+    lines.push('## Edges');
+    for (const e of nbrs.edges) {
+      lines.push(`- ${e.from_type}/${e.from_name} --${e.edge_type}--> ${e.to_type}/${e.to_name}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function dumpTypeList(store, type) {
+  const lines = [];
+  const rows = await listEntities(store, { type });
+  lines.push(`# entities of type '${type}' (${rows.length})`);
+  for (const r of rows) lines.push(`- ${r.name}`);
+  return lines.join('\n');
+}
+
+async function dumpSummary(store, vocabulary) {
+  const lines = [];
+  lines.push('# memory summary');
+  for (const t of Object.keys(vocabulary.entities)) {
+    const rows = await listEntities(store, { type: t });
+    lines.push(`- entity ${t}: ${rows.length} rows`);
+  }
+  for (const t of Object.keys(vocabulary.edges)) {
+    const res = await store.db.run(`?[ft, fn, tt, tn] := *edge_${t}{from_type: ft, from_name: fn, to_type: tt, to_name: tn}`);
+    lines.push(`- edge ${t}: ${res.rows.length} rows`);
+  }
+  return lines.join('\n');
+}
+
+export async function dumpMemory({ store, vocabulary, type, name, depth = 1 }) {
+  if (type && name) return dumpSingleEntity(store, vocabulary, type, name);
+  if (type) return dumpTypeList(store, type);
+  return dumpSummary(store, vocabulary);
+}

package/dist/scripts/lib/memory/admin/helpers.js

@@ -0,0 +1,31 @@
+/**
+ * Shared helpers for memory admin operations.
+ */
+
+/**
+ * Render edge frontmatter as YAML.
+ * @param {Object} fm - Frontmatter object with type, sources, targets
+ * @returns {string} YAML frontmatter content (without delimiters)
+ */
+export function renderEdgeFrontmatter(fm) {
+  const lines = [`type: ${fm.type}`];
+  for (const key of ['sources', 'targets']) {
+    const v = fm[key];
+    lines.push(v === 'any' ? `${key}: any` : `${key}: [${v.join(', ')}]`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Compose a markdown file from frontmatter and body.
+ * Handles the "strip leading newline from body if present" pattern
+ * used throughout memory admin modules.
+ * 
+ * @param {string} frontmatter - YAML frontmatter content (without delimiters)
+ * @param {string} body - Markdown body content
+ * @returns {string} Complete markdown file with frontmatter delimiters
+ */
+export function composeMarkdown(frontmatter, body) {
+  const normalizedBody = body.startsWith('\n') ? body.slice(1) : body;
+  return `---\n${frontmatter}\n---\n${normalizedBody}`;
+}

package/dist/scripts/lib/memory/admin/init.js

@@ -0,0 +1,170 @@
+import { join } from 'node:path';
+import { memoryPaths } from '../paths.js';
+import { DEFAULT_CONFIG } from '../config.js';
+import { renderMarkdown } from '../frontmatter.js';
+import { probeEmbeddings } from '../embeddings.js';
+
+const CONFIG_BODY = `
+# Memory configuration
+
+This project uses Foundry flow memory. Add prose notes here if helpful.
+
+The embedding provider defaults to a local Ollama instance. Edit the
+frontmatter to point at a different OpenAI-compatible endpoint, or set
+\`embeddings.enabled: false\` if you don't want vector search.
+`;
+
+// Gitignore only the runtime DB files under foundry/memory/.
+// foundry-memory/relations/ (NDJSON row data) is intentionally tracked.
+const DEFAULT_GITIGNORE_ENTRIES = [
+  'foundry/memory/memory.db',
+  'foundry/memory/memory.db-wal',
+  'foundry/memory/memory.db-shm',
+];
+
+function buildEmbeddingsBlock(embeddingsEnabled) {
+  const d = DEFAULT_CONFIG.embeddings;
+  return {
+    enabled: embeddingsEnabled,
+    baseURL: d.baseURL,
+    model: d.model,
+    dimensions: d.dimensions,
+    apiKey: null,
+    batchSize: d.batchSize,
+    timeoutMs: d.timeoutMs,
+  };
+}
+
+function buildConfigFm(embeddingsBlock) {
+  return {
+    enabled: true,
+    validation: 'strict',
+    embeddings: embeddingsBlock,
+  };
+}
+
+async function createGitkeeps(io, dirs, created) {
+  for (const d of dirs) {
+    const f = join(d, '.gitkeep');
+    await io.writeFile(f, '');
+    created.push(f);
+  }
+}
+
+function handleProbeError(err) {
+  return { ok: false, error: err?.message ?? String(err) };
+}
+
+async function runProbe(embeddingsBlock) {
+  try {
+    const result = await probeEmbeddings({ config: embeddingsBlock });
+    if (result.ok) {
+      return { probeResult: result, actualDimensions: result.dimensions };
+    }
+    return { probeResult: result, actualDimensions: DEFAULT_CONFIG.embeddings.dimensions };
+  } catch (err) {
+    return { probeResult: handleProbeError(err), actualDimensions: DEFAULT_CONFIG.embeddings.dimensions };
+  }
+}
+
+async function probeEmbeddingsIfNeeded(embeddingsEnabled, probe, embeddingsBlock) {
+  if (!probe || !embeddingsEnabled) {
+    return { probeResult: null, actualDimensions: DEFAULT_CONFIG.embeddings.dimensions };
+  }
+  return runProbe(embeddingsBlock);
+}
+
+function buildSchema(embeddingsEnabled, model, dimensions) {
+  return {
+    version: 1,
+    entities: {},
+    edges: {},
+    embeddings: embeddingsEnabled
+      ? { model, dimensions }
+      : null,
+  };
+}
+
+async function validatePrerequisites(io, p) {
+  if (!(await io.exists('foundry'))) {
+    throw new Error('foundry/ does not exist; run init-foundry first');
+  }
+  if (await io.exists(p.root)) {
+    throw new Error('foundry/memory/ already exists');
+  }
+  if (await io.exists('foundry-memory')) {
+    throw new Error('foundry-memory/ already exists');
+  }
+}
+
+async function writeConfigFile(io, configPath, embeddingsEnabled) {
+  const embeddingsBlock = buildEmbeddingsBlock(embeddingsEnabled);
+  const configFm = buildConfigFm(embeddingsBlock);
+  await io.writeFile(configPath, renderMarkdown(configFm, CONFIG_BODY));
+  return embeddingsBlock;
+}
+
+/**
+ * Scaffold `foundry/memory/` and `foundry-memory/relations/` deterministically.
+ *
+ * Creates:
+ *   - entities/.gitkeep, edges/.gitkeep under foundry/memory/
+ *   - foundry-memory/relations/.gitkeep (sibling of foundry/, holds row data)
+ *   - config.md (frontmatter derived from DEFAULT_CONFIG)
+ *   - schema.json (version 1, empty entities/edges, embeddings block
+ *     populated from probe when enabled, null otherwise)
+ *   - appends .gitignore entries (idempotent)
+ *
+ * When `embeddingsEnabled && probe`, probes the embedding provider first, then
+ * writes schema.json with the actual dimensions returned by the probe (if
+ * successful). If probe fails or is disabled, uses DEFAULT_CONFIG dimensions.
+ * The caller decides whether to surface probe failure to the user — initMemory
+ * itself does not fail on a bad probe (config.md already on disk with sensible
+ * defaults can be edited).
+ *
+ * @param {object} opts
+ * @param {object} opts.io                    memory-style IO (exists, readFile, writeFile, mkdir)
+ * @param {boolean} [opts.embeddingsEnabled]  default true
+ * @param {boolean} [opts.probe]              default true; only runs if embeddingsEnabled
+ * @returns {Promise<{ created: string[], gitignoreAdded: string[], probe: object|null }>}
+ */
+export async function initMemory({ io, embeddingsEnabled = true, probe = true }) {
+  const p = memoryPaths('foundry');
+  await validatePrerequisites(io, p);
+
+  const created = [];
+
+  await io.mkdir(p.entitiesDir);
+  await io.mkdir(p.edgesDir);
+  await io.mkdir(p.relationsDir);
+  await createGitkeeps(io, [p.entitiesDir, p.edgesDir, p.relationsDir], created);
+
+  const embeddingsBlock = await writeConfigFile(io, p.config, embeddingsEnabled);
+  created.push(p.config);
+
+  const gitignoreAdded = await appendGitignore(io, DEFAULT_GITIGNORE_ENTRIES);
+
+  const { probeResult, actualDimensions } = await probeEmbeddingsIfNeeded(
+    embeddingsEnabled,
+    probe,
+    embeddingsBlock,
+  );
+
+  const schema = buildSchema(embeddingsEnabled, DEFAULT_CONFIG.embeddings.model, actualDimensions);
+  await io.writeFile(p.schema, JSON.stringify(schema, null, 2) + '\n');
+  created.push(p.schema);
+
+  return { created, gitignoreAdded, probe: probeResult };
+}
+
+async function appendGitignore(io, entries) {
+  const path = '.gitignore';
+  const exists = await io.exists(path);
+  const current = exists ? await io.readFile(path) : '';
+  const present = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+  const toAdd = entries.filter((e) => !present.has(e));
+  if (toAdd.length === 0) return [];
+  const tail = current.length === 0 || current.endsWith('\n') ? '' : '\n';
+  await io.writeFile(path, current + tail + toAdd.join('\n') + '\n');
+  return toAdd;
+}

package/dist/scripts/lib/memory/admin/live-store.js

@@ -0,0 +1,76 @@
+import { join } from 'node:path';
+import {
+  openMemoryDb,
+  closeMemoryDb,
+  createEntityRelation,
+  createEdgeRelation,
+  createHnswIndex,
+  dropRelation,
+  dropHnswIndex,
+  entRelName,
+  edgeRelName,
+  cozoStringLit,
+} from '../cozo.js';
+import { memoryPaths } from '../paths.js';
+
+function errDisplayMessage(err) {
+  return String(err && (err.display || err.message || err));
+}
+
+async function dropRelationIfPresent(db, relationName) {
+  try {
+    await dropRelation(db, relationName);
+  } catch (err) {
+    if (/not found|does not exist|no such/i.test(errDisplayMessage(err))) return;
+    throw err;
+  }
+}
+
+export async function withLiveMemoryDb({ worktreeRoot, io }, fn) {
+  const foundryDir = 'foundry';
+  const paths = memoryPaths(foundryDir);
+  if (!(await io.exists(paths.db))) return;
+
+  const db = openMemoryDb(join(worktreeRoot, paths.db));
+  try {
+    await fn(db);
+  } finally {
+    closeMemoryDb(db);
+  }
+}
+
+export async function createLiveEntityType(db, name, { embeddingsDim } = {}) {
+  await createEntityRelation(db, name, embeddingsDim ? { dim: embeddingsDim } : {});
+  if (embeddingsDim) {
+    await createHnswIndex(db, entRelName(name), { dim: embeddingsDim });
+  }
+}
+
+export async function createLiveEdgeType(db, name) {
+  await createEdgeRelation(db, name);
+}
+
+export async function dropLiveEntityType(db, name) {
+  await dropHnswIndex(db, entRelName(name));
+  await dropRelationIfPresent(db, entRelName(name));
+}
+
+export async function dropLiveEdgeType(db, name) {
+  await dropRelationIfPresent(db, edgeRelName(name));
+}
+
+export async function replaceLiveEdgeRows(db, name, rows) {
+  const relationName = edgeRelName(name);
+  await dropRelationIfPresent(db, relationName);
+  await createEdgeRelation(db, name);
+  if (rows.length === 0) return;
+
+  const data = rows
+    .map((row) => `[` +
+      `${cozoStringLit(row.from_type)}, ${cozoStringLit(row.from_name)}, ` +
+      `${cozoStringLit(row.to_type)}, ${cozoStringLit(row.to_name)}]`)
+    .join(', ');
+  await db.run(
+    `?[from_type, from_name, to_type, to_name] <- [${data}]\n:put ${relationName} { from_type, from_name, to_type, to_name }`,
+  );
+}