@really-knows-ai/foundry 2.3.1 → 3.0.0

package/dist/scripts/lib/memory/cozo.js

@@ -0,0 +1,136 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+let CozoDb = null;
+try {
+  ({ CozoDb } = require('cozo-node'));
+} catch {
+  // cozo-node is optional; memory features are unavailable on this platform
+}
+
+function assertCozo() {
+  if (!CozoDb) {
+    throw new Error(
+      'cozo-node is not installed on this platform. ' +
+      'Install it to enable the memory subsystem: pnpm add cozo-node'
+    );
+  }
+}
+
+export function openMemoryDb(dbPath) {
+  assertCozo();
+  return new CozoDb('sqlite', dbPath);
+}
+
+export function closeMemoryDb(db) {
+  if (db && typeof db.close === 'function') db.close();
+}
+
+/**
+ * Canonical Cozo string literal encoder.
+ *
+ * Emits a **single-quoted** literal. Single-quoted literals honour standard
+ * escape sequences and safely handle embedded `"`, `\`, newlines, CR, tabs,
+ * and backslashes, producing a safe round-trip for all supported characters.
+ * (Cozo's `"..."` form is raw and stores backslash sequences literally.)
+ *
+ * Used by every query builder in this package so read and write paths never
+ * diverge on what they consider a safe literal. NUL characters are rejected
+ * here because Cozo single-quoted string literals lack `\0` escape support.
+ * The write path (putEntity, relate, unrelate) also validates for NUL in
+ * validateEntityWrite/validateEdgeWrite, providing defence in depth for
+ * import paths and future callers.
+ */
+export function cozoStringLit(s) {
+  const str = String(s);
+  if (str.includes('\0')) {
+    throw new Error('cozoStringLit: string must not contain NUL (\\0)');
+  }
+  const escaped = str
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+  return `'${escaped}'`;
+}
+
+function entRelName(type) { return `ent_${type}`; }
+function edgeRelName(type) { return `edge_${type}`; }
+
+async function relationExists(db, name) {
+  const res = await db.run('::relations');
+  return res.rows.some((r) => r[0] === name);
+}
+
+export async function listRelations(db) {
+  const res = await db.run('::relations');
+  return res.rows.map((r) => r[0]);
+}
+
+export async function createEntityRelation(db, type, opts = {}) {
+  const name = entRelName(type);
+  if (await relationExists(db, name)) return;
+  const { dim } = opts;
+  // Cozo 0.7 requires a typed vector (<F32; N>) for HNSW indexing. When no
+  // embeddings are configured we keep the flexible [Float]? column so the
+  // relation can still be created and written to without embeddings.
+  const embeddingCol = Number.isInteger(dim) && dim > 0
+    ? `embedding: <F32; ${dim}>? default null`
+    : `embedding: [Float]? default null`;
+  await db.run(`:create ${name} { name: String => value: String, ${embeddingCol} }`);
+}
+
+export async function createEdgeRelation(db, type) {
+  const name = edgeRelName(type);
+  if (await relationExists(db, name)) return;
+  await db.run(`:create ${name} { from_type: String, from_name: String, to_type: String, to_name: String }`);
+}
+
+export async function dropRelation(db, relationName) {
+  await db.run(`::remove ${relationName}`);
+}
+
+function isIgnorableError(err, patterns) {
+  const msg = String(err && (err.display || err.message || err));
+  return patterns.some((p) => p.test(msg));
+}
+
+function assertHnswDim(dim) {
+  if (!Number.isInteger(dim) || dim <= 0) throw new Error('createHnswIndex: dim must be positive integer');
+}
+
+function resolveHnswOpts(opts) {
+  const { dim, ef = 50, m = 16 } = opts ?? {};
+  return { dim, ef, m };
+}
+
+export async function createHnswIndex(db, relationName, opts) {
+  const { dim, ef, m } = resolveHnswOpts(opts);
+  assertHnswDim(dim);
+  try {
+    await db.run(`::hnsw create ${relationName}:vec { fields: [embedding], dim: ${dim}, ef: ${ef}, m: ${m} }`);
+  } catch (err) {
+    if (isIgnorableError(err, [/already exists/i, /already created/i])) return;
+    throw err;
+  }
+}
+
+export async function dropHnswIndex(db, relationName) {
+  try {
+    await db.run(`::hnsw drop ${relationName}:vec`);
+  } catch (err) {
+    if (isIgnorableError(err, [/not found/i, /does not exist/i, /no such/i])) return;
+    throw err;
+  }
+}
+
+export async function checkpoint(db) {
+  try {
+    await db.run('::compact');
+  } catch (err) {
+    if (!isIgnorableError(err, [/unknown system op/i, /parser::pest/i])) throw err;
+  }
+}
+
+export { entRelName, edgeRelName };

package/dist/scripts/lib/memory/drift.js

@@ -0,0 +1,71 @@
+import { hashFrontmatter } from './schema.js';
+
+function compareLoadedType({ family, name, loadedEntry, recordedEntry }) {
+  const currentHash = hashFrontmatter(loadedEntry.frontmatter);
+  if (currentHash !== recordedEntry.frontmatterHash) {
+    return {
+      kind: 'frontmatter-mismatch',
+      typeFamily: family,
+      typeName: name,
+      message: `${family} type '${name}' frontmatter was modified outside of a skill`,
+      suggestedSkills: [`rename-memory-${family}-type`, `drop-memory-${family}-type`],
+    };
+  }
+  return null;
+}
+
+function findMissingFiles({ family, loadedNames, recordedNames }) {
+  const items = [];
+  for (const name of recordedNames) {
+    if (!loadedNames.has(name)) {
+      items.push({
+        kind: 'missing-file',
+        typeFamily: family,
+        typeName: name,
+        message: `${family} type '${name}' is recorded in schema.json but its file is missing on disk`,
+        suggestedSkills: [`drop-memory-${family}-type`, `rename-memory-${family}-type`],
+      });
+    }
+  }
+  return items;
+}
+
+function compareFamily({ family, loaded, recorded }) {
+  const items = [];
+  const loadedNames = new Set(Object.keys(loaded));
+  const recordedNames = new Set(Object.keys(recorded));
+
+  for (const name of loadedNames) {
+    if (!recordedNames.has(name)) {
+      items.push({
+        kind: 'unknown-type',
+        typeFamily: family,
+        typeName: name,
+        message: `${family} type '${name}' exists on disk but is not recorded in schema.json`,
+        suggestedSkills: [`add-memory-${family}-type`],
+      });
+      continue;
+    }
+    const item = compareLoadedType({
+      family,
+      name,
+      loadedEntry: loaded[name],
+      recordedEntry: recorded[name],
+    });
+    if (item) {
+      items.push(item);
+    }
+  }
+
+  items.push(...findMissingFiles({ family, loadedNames, recordedNames }));
+
+  return items;
+}
+
+export function detectDrift({ vocabulary, schema }) {
+  const items = [
+    ...compareFamily({ family: 'entity', loaded: vocabulary.entities, recorded: schema.entities }),
+    ...compareFamily({ family: 'edge', loaded: vocabulary.edges, recorded: schema.edges }),
+  ];
+  return { hasDrift: items.length > 0, items };
+}

package/dist/scripts/lib/memory/embeddings.js

@@ -0,0 +1,128 @@
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+
+function isRetryableStatus(statusCode) {
+  return statusCode !== null && statusCode !== undefined && RETRYABLE_STATUS_CODES.has(statusCode);
+}
+
+function isRetryableError(error, statusCode) {
+  if (isRetryableStatus(statusCode)) return true;
+  if (error?.message?.match(/abort|timeout/i)) return true;
+  return false;
+}
+
+function assertResponseOk(res) {
+  if (!res.ok) return res;
+  return null;
+}
+
+async function parseEmbeddings(body) {
+  if (!Array.isArray(body.data)) throw new Error('embeddings provider returned malformed response (no data[])');
+  for (const item of body.data) {
+    if (!('index' in item)) {
+      throw new Error('embedding provider returned data without index field - cannot verify ordering');
+    }
+  }
+  return body.data
+    .sort((a, b) => a.index - b.index)
+    .map((d) => d.embedding);
+}
+
+async function callOnce({ config, inputs }) {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), config.timeoutMs);
+  try {
+    const headers = { 'Content-Type': 'application/json' };
+    if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+    const res = await fetch(`${config.baseURL}/embeddings`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ model: config.model, input: inputs }),
+      signal: ac.signal,
+    });
+    const errRes = assertResponseOk(res);
+    if (errRes) {
+      const text = await res.text().catch(() => '');
+      const error = new Error(`embeddings provider returned ${res.status}: ${text.slice(0, 500)}`);
+      error.statusCode = res.status;
+      throw error;
+    }
+    const body = await res.json();
+    return parseEmbeddings(body);
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+function shouldGiveUp(attempt, maxAttempts, error) {
+  const isLastAttempt = attempt === maxAttempts - 1;
+  if (isLastAttempt) return true;
+  if (!isRetryableError(error, error.statusCode)) return true;
+  return false;
+}
+
+function buildRetryError(error, attempt) {
+  return new Error(`${error.message} (after ${attempt} retries)`, { cause: error });
+}
+
+async function callWithRetry({ config, inputs }) {
+  const maxAttempts = 3;
+  const delays = [1000, 2000]; // 1s, 2s backoff
+  let lastError;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await callOnce({ config, inputs });
+    } catch (error) {
+      lastError = error;
+      if (shouldGiveUp(attempt, maxAttempts, error)) {
+        if (attempt > 0) throw buildRetryError(error, attempt);
+        throw error;
+      }
+      await new Promise((resolve) => { setTimeout(resolve, delays[attempt]); });
+    }
+  }
+
+  // This should never be reached, but TypeScript/linters like it
+  throw lastError;
+}
+
+function assertVectorShape(v, dimensions) {
+  if (!Array.isArray(v) || v.length !== dimensions) {
+    throw new Error(`embedding dimension mismatch: expected ${dimensions}, got ${Array.isArray(v) ? v.length : 'non-array'}`);
+  }
+}
+
+function assertVectorFinite(v) {
+  for (const x of v) if (!Number.isFinite(x)) throw new Error('embedding contains non-finite number');
+}
+
+function validateVector(v, dimensions) {
+  assertVectorShape(v, dimensions);
+  assertVectorFinite(v);
+}
+
+export async function embed({ config, inputs }) {
+  if (!config.enabled) throw new Error('embeddings are disabled in memory config');
+  if (!Array.isArray(inputs) || inputs.length === 0) return [];
+  return embedBatches(config, inputs);
+}
+
+async function embedBatches(config, inputs) {
+  const out = [];
+  for (let i = 0; i < inputs.length; i += config.batchSize) {
+    const batch = inputs.slice(i, i + config.batchSize);
+    const vectors = await callWithRetry({ config, inputs: batch });
+    for (const v of vectors) validateVector(v, config.dimensions);
+    out.push(...vectors);
+  }
+  return out;
+}
+
+export async function probeEmbeddings({ config }) {
+  try {
+    const out = await embed({ config, inputs: ['probe'] });
+    return { ok: true, dimensions: out[0].length };
+  } catch (err) {
+    return { ok: false, error: err.message ?? String(err) };
+  }
+}

package/dist/scripts/lib/memory/frontmatter.js

@@ -0,0 +1,75 @@
+import yaml from 'js-yaml';
+
+/**
+ * Safely parse a YAML string, rethrowing with a filename-prefixed message
+ * on failure so errors are actionable.
+ *
+ * @param {string} yamlStr
+ * @param {string} filename
+ * @returns {unknown}
+ */
+function safeYamlLoad(yamlStr, filename) {
+  try {
+    return yaml.load(yamlStr);
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    throw new Error(`${filename}: malformed YAML frontmatter: ${msg}`, { cause: err });
+  }
+}
+
+/**
+ * Normalise a parsed YAML value into a frontmatter object.
+ *
+ * @param {unknown} parsed
+ * @returns {object}
+ */
+function normaliseFrontmatter(parsed) {
+  if (parsed && typeof parsed === 'object') {
+    return /** @type {object} */ (parsed);
+  }
+  return {};
+}
+
+/**
+ * Parse a markdown document with YAML frontmatter.
+ *
+ * Accepts both LF and CRLF line endings (so files saved on Windows parse the
+ * same as files saved on Unix). Returns the parsed frontmatter object, the
+ * body (text after the closing `---`, untrimmed), and a `hasFrontmatter`
+ * flag. The body preserves original line endings.
+ *
+ * Throws with a filename-prefixed message on malformed YAML so errors are
+ * actionable (bare `YAMLException` from `js-yaml` gives no file context).
+ *
+ * NOTE: Intentionally duplicates core logic from ../workfile.js for different
+ * use cases. This version provides full error handling and returns structured
+ * metadata; workfile.js provides a simpler interface for WORK.md manipulation.
+ *
+ * @param {string} text
+ * @param {{ filename?: string }} [opts]
+ * @returns {{ frontmatter: object, body: string, hasFrontmatter: boolean }}
+ */
+export function parseFrontmatter(text, { filename = '<unknown>' } = {}) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) {
+    return { frontmatter: {}, body: text, hasFrontmatter: false };
+  }
+  const parsed = safeYamlLoad(m[1], filename);
+  return {
+    frontmatter: normaliseFrontmatter(parsed),
+    body: m[2] ?? '',
+    hasFrontmatter: true,
+  };
+}
+
+/**
+ * Render a markdown document from a frontmatter object and a body string.
+ * Uses `yaml.dump` — callers that need a specific key order (e.g. edge type
+ * files where `sources`/`targets` are rendered as inline YAML arrays) should
+ * build the YAML text themselves and wrap with `---\n...\n---\n`.
+ */
+export function renderMarkdown(frontmatter, body = '') {
+  const yamlText = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true }).replace(/\n$/, '');
+  const prefix = body.startsWith('\n') ? '' : '\n';
+  return `---\n${yamlText}\n---\n${prefix}${body}`;
+}

package/dist/scripts/lib/memory/ndjson.js

@@ -0,0 +1,84 @@
+function assertFiniteNumber(value, path) {
+  if (typeof value === 'number' && !Number.isFinite(value)) {
+    throw new Error(`NDJSON: non-finite number at ${path}`);
+  }
+}
+
+function assertFiniteArray(value, path) {
+  value.forEach((v, i) => assertFiniteNumbers(v, `${path}[${i}]`));
+}
+
+function assertFiniteObject(value, path) {
+  for (const [k, v] of Object.entries(value)) assertFiniteNumbers(v, `${path}.${k}`);
+}
+
+function assertFiniteNumbers(value, path) {
+  assertFiniteNumber(value, path);
+  if (Array.isArray(value)) {
+    assertFiniteArray(value, path);
+    return;
+  }
+  if (value && typeof value === 'object') {
+    assertFiniteObject(value, path);
+  }
+}
+
+function canonicalise(value) {
+  if (Array.isArray(value)) return value.map(canonicalise);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const k of Object.keys(value).sort()) out[k] = canonicalise(value[k]);
+    return out;
+  }
+  return value;
+}
+
+function serialiseLine(row) {
+  assertFiniteNumbers(row, 'row');
+  return JSON.stringify(canonicalise(row));
+}
+
+function compareEntity(a, b) {
+  if (a.name < b.name) return -1;
+  if (a.name > b.name) return 1;
+  return 0;
+}
+
+const EDGE_KEY_ORDER = ['from_type', 'from_name', 'to_type', 'to_name'];
+function compareEdge(a, b) {
+  for (const k of EDGE_KEY_ORDER) {
+    if (a[k] < b[k]) return -1;
+    if (a[k] > b[k]) return 1;
+  }
+  return 0;
+}
+
+export function serialiseEntityRows(rows) {
+  if (rows.length === 0) return '';
+  const sorted = [...rows].sort(compareEntity);
+  return sorted.map(serialiseLine).join('\n') + '\n';
+}
+
+export function serialiseEdgeRows(rows) {
+  if (rows.length === 0) return '';
+  const sorted = [...rows].sort(compareEdge);
+  return sorted.map(serialiseLine).join('\n') + '\n';
+}
+
+function parseLines(text) {
+  const out = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === '') continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch (err) {
+      throw new Error(`NDJSON: invalid JSON at line ${i + 1}: ${err.message}`, { cause: err });
+    }
+  }
+  return out;
+}
+
+export const parseEntityRows = parseLines;
+export const parseEdgeRows = parseLines;

package/dist/scripts/lib/memory/paths.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+
+export function memoryPaths(foundryDir) {
+  const root = join(foundryDir, 'memory');
+  const entitiesDir = join(root, 'entities');
+  const edgesDir = join(root, 'edges');
+  // Phase 2 moved relations out of foundry/ to foundry-memory/relations/
+  // (sibling to foundry/). Derive from foundryDir using '..' to go up one level.
+  const relationsDir = join(foundryDir, '..', 'foundry-memory', 'relations');
+  const extractorsDir = join(root, 'extractors');
+  return {
+    root,
+    config: join(root, 'config.md'),
+    schema: join(root, 'schema.json'),
+    entitiesDir,
+    edgesDir,
+    relationsDir,
+    extractorsDir,
+    db: join(root, 'memory.db'),
+    entityTypeFile: (name) => join(entitiesDir, `${name}.md`),
+    edgeTypeFile: (name) => join(edgesDir, `${name}.md`),
+    relationFile: (name) => join(relationsDir, `${name}.ndjson`),
+    extractorFile: (name) => join(extractorsDir, `${name}.md`),
+  };
+}

package/dist/scripts/lib/memory/permissions.js

@@ -0,0 +1,41 @@
+function filterValidTypes(types, vocabulary) {
+  const result = new Set();
+  for (const t of types ?? []) {
+    if (vocabulary.entities[t]) result.add(t);
+  }
+  return result;
+}
+
+export function resolvePermissions({ cycleFrontmatter, vocabulary }) {
+  const mem = cycleFrontmatter?.memory;
+  if (!mem || typeof mem !== 'object') {
+    return { enabled: false, readTypes: new Set(), writeTypes: new Set(), vocabulary };
+  }
+  const readTypes = filterValidTypes(mem.read, vocabulary);
+  const writeTypes = filterValidTypes(mem.write, vocabulary);
+  return { enabled: readTypes.size > 0 || writeTypes.size > 0, readTypes, writeTypes, vocabulary };
+}
+
+function endpointInSet(endpointSpec, set) {
+  if (endpointSpec === 'any') return set.size > 0;
+  return endpointSpec.some((t) => set.has(t));
+}
+
+export function checkEntityRead(perms, type) { return perms.readTypes.has(type); }
+export function checkEntityWrite(perms, type) { return perms.writeTypes.has(type); }
+
+export function checkEdgeRead(perms, edgeType) {
+  const edge = perms.vocabulary.edges[edgeType];
+  if (!edge) return false;
+  return endpointInSet(edge.sources, perms.readTypes)
+      || endpointInSet(edge.targets, perms.readTypes)
+      || endpointInSet(edge.sources, perms.writeTypes)
+      || endpointInSet(edge.targets, perms.writeTypes);
+}
+
+export function checkEdgeWrite(perms, edgeType) {
+  const edge = perms.vocabulary.edges[edgeType];
+  if (!edge) return false;
+  return endpointInSet(edge.sources, perms.writeTypes)
+      || endpointInSet(edge.targets, perms.writeTypes);
+}

package/dist/scripts/lib/memory/prompt.js

@@ -0,0 +1,109 @@
+import { checkEdgeRead, checkEdgeWrite } from './permissions.js';
+
+function entityBlock(name, typeDef, isWrite) {
+  return [
+    `### entity: \`${name}\` (${isWrite ? 'read+write' : 'read-only'})`,
+    '',
+    typeDef.body ?? '(no description)',
+    '',
+  ].join('\n');
+}
+
+function edgeBlock(name, edgeDef, canWrite) {
+  const renderList = (v) => v === 'any' ? 'any' : `[${v.join(', ')}]`;
+  return [
+    `### edge: \`${name}\` (${canWrite ? 'read+write' : 'read-only'})`,
+    `Sources: ${renderList(edgeDef.sources)}. Targets: ${renderList(edgeDef.targets)}.`,
+    '',
+    edgeDef.body ?? '(no description)',
+    '',
+  ].join('\n');
+}
+
+function extractorBlock({ name, body }) {
+  return [
+    `### extractor: \`${name}\``,
+    '',
+    (body && body.trim()) ? body.trim() : '(no description)',
+    '',
+  ].join('\n');
+}
+
+function renderToolLines(embeddingsEnabled, hasWriteTypes) {
+  const lines = [
+    '### Memory tools available to you',
+    '',
+    '- `foundry_memory_get(type, name)` — fetch an entity (null if absent).',
+    '- `foundry_memory_list(type)` — list all entities of a type.',
+    '- `foundry_memory_neighbours(type, name, depth?, edge_types?)` — bounded graph traversal.',
+    '- `foundry_memory_query(datalog)` — arbitrary read-only Cozo Datalog.',
+  ];
+  if (embeddingsEnabled) {
+    lines.push('- `foundry_memory_search(type, query, limit?)` — semantic (vector) search over entities of a type.');
+  }
+  if (hasWriteTypes) {
+    lines.push('- `foundry_memory_put(type, name, value)` — upsert an entity (≤4KB value).');
+    lines.push('- `foundry_memory_relate(from_type, from_name, edge_type, to_type, to_name)` — upsert an edge.');
+    lines.push('- `foundry_memory_unrelate(...)` — delete an edge.');
+  }
+  lines.push('');
+  lines.push('Writes to types outside your permissions are rejected.');
+  lines.push('');
+  return lines;
+}
+
+function renderEntityLines(allTypes, vocabulary, writeTypes) {
+  const lines = [];
+  for (const name of [...allTypes].sort()) {
+    lines.push(entityBlock(name, vocabulary.entities[name], writeTypes.has(name)));
+  }
+  return lines;
+}
+
+function renderEdgeLines(permissions, vocabulary) {
+  const visibleEdges = Object.keys(vocabulary.edges)
+    .filter((n) => checkEdgeRead(permissions, n))
+    .sort();
+  if (visibleEdges.length === 0) return [];
+  const lines = ['Edges visible to this cycle:', ''];
+  for (const name of visibleEdges) {
+    lines.push(edgeBlock(name, vocabulary.edges[name], checkEdgeWrite(permissions, name)));
+  }
+  return lines;
+}
+
+function renderExtractorSection(extractors) {
+  if (!Array.isArray(extractors) || extractors.length === 0) return [];
+  const lines = ['## Extractors', ''];
+  lines.push('The following extractors populate this cycle\'s memory during the assay stage. Their prose briefs describe what gets captured:');
+  lines.push('');
+  for (const ex of extractors) {
+    lines.push(extractorBlock(ex));
+  }
+  return lines;
+}
+
+export function renderMemoryPrompt({ permissions, schema, extractors }) {
+  if (!permissions.enabled) return '';
+
+  const { readTypes, writeTypes, vocabulary } = permissions;
+  const embeddingsEnabled = Boolean(schema?.embeddings?.dimensions);
+  const allTypes = new Set([...readTypes, ...writeTypes]);
+
+  const lines = [
+    '## Flow memory',
+    '',
+    'You have access to a typed, graph-shaped memory store. Use it to save what you learn and to query what previous cycles learned.',
+    '',
+    'Types visible to this cycle:',
+    '',
+  ];
+
+  lines.push(...renderEntityLines(allTypes, vocabulary, writeTypes));
+  lines.push(...renderEdgeLines(permissions, vocabulary));
+
+  lines.push(...renderToolLines(embeddingsEnabled, writeTypes.size > 0));
+  lines.push(...renderExtractorSection(extractors));
+
+  return lines.join('\n');
+}