rlhf-feedback-loop 0.6.10 → 0.6.12

package/scripts/sync-version.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Version Sync — Single Source of Truth
+ *
+ * Reads the version from package.json and propagates it to all
+ * manifests and public docs. Eliminates version drift permanently.
+ *
+ * Inspired by the "Pipeline Doctor" pattern (Optimum Partners, 2026)
+ * and OneUptime's automated version bumping approach.
+ *
+ * Usage:
+ *   node scripts/sync-version.js          # Sync all files
+ *   node scripts/sync-version.js --check  # Dry-run: report drift without fixing
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+
+function readJson(relPath) {
+  return JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, relPath), 'utf-8'));
+}
+
+function writeJson(relPath, data) {
+  fs.writeFileSync(path.join(PROJECT_ROOT, relPath), JSON.stringify(data, null, 2) + '\n');
+}
+
+function replaceInFile(relPath, search, replace) {
+  const filePath = path.join(PROJECT_ROOT, relPath);
+  if (!fs.existsSync(filePath)) return false;
+  const content = fs.readFileSync(filePath, 'utf-8');
+  if (!content.includes(search)) return false;
+  fs.writeFileSync(filePath, content.split(search).join(replace));
+  return true;
+}
+
+function syncVersion(opts) {
+  const options = opts || {};
+  const checkOnly = options.check || false;
+  const pkg = readJson('package.json');
+  const version = pkg.version;
+
+  const targets = [];
+  const drifted = [];
+
+  // 1. server.json — top-level version + packages[0].version
+  const serverJson = readJson('server.json');
+  if (serverJson.version !== version) {
+    drifted.push({ file: 'server.json', field: 'version', current: serverJson.version });
+    if (!checkOnly) {
+      serverJson.version = version;
+      if (serverJson.packages && serverJson.packages[0]) {
+        serverJson.packages[0].version = version;
+      }
+      writeJson('server.json', serverJson);
+    }
+  } else if (serverJson.packages && serverJson.packages[0] && serverJson.packages[0].version !== version) {
+    drifted.push({ file: 'server.json', field: 'packages[0].version', current: serverJson.packages[0].version });
+    if (!checkOnly) {
+      serverJson.packages[0].version = version;
+      writeJson('server.json', serverJson);
+    }
+  }
+  targets.push('server.json');
+
+  // 2. .well-known/mcp/server-card.json
+  const cardPath = '.well-known/mcp/server-card.json';
+  if (fs.existsSync(path.join(PROJECT_ROOT, cardPath))) {
+    const card = readJson(cardPath);
+    if (card.version !== version) {
+      drifted.push({ file: cardPath, field: 'version', current: card.version });
+      if (!checkOnly) {
+        card.version = version;
+        writeJson(cardPath, card);
+      }
+    }
+    targets.push(cardPath);
+  }
+
+  // 3. docs/landing-page.html — hero badge + JSON snippet
+  const landingPath = 'docs/landing-page.html';
+  if (fs.existsSync(path.join(PROJECT_ROOT, landingPath))) {
+    const landingContent = fs.readFileSync(path.join(PROJECT_ROOT, landingPath), 'utf-8');
+    // Match any version pattern in the hero badge
+    const badgeMatch = landingContent.match(/v(\d+\.\d+\.\d+) — Hosted API/);
+    if (badgeMatch && badgeMatch[1] !== version) {
+      drifted.push({ file: landingPath, field: 'hero-badge', current: badgeMatch[1] });
+      if (!checkOnly) {
+        replaceInFile(landingPath, `v${badgeMatch[1]} — Hosted API`, `v${version} — Hosted API`);
+      }
+    }
+    // JSON snippet version
+    const jsonMatch = landingContent.match(/"version"<\/span><span class="out">: <\/span><span class="val">"(\d+\.\d+\.\d+)"/);
+    if (jsonMatch && jsonMatch[1] !== version) {
+      drifted.push({ file: landingPath, field: 'json-snippet', current: jsonMatch[1] });
+      if (!checkOnly) {
+        replaceInFile(landingPath, `"${jsonMatch[1]}"</div>`, `"${version}"</div>`);
+      }
+    }
+    targets.push(landingPath);
+  }
+
+  // 4. docs/mcp-hub-submission.md
+  const mcpSubmPath = 'docs/mcp-hub-submission.md';
+  if (fs.existsSync(path.join(PROJECT_ROOT, mcpSubmPath))) {
+    const mcpContent = fs.readFileSync(path.join(PROJECT_ROOT, mcpSubmPath), 'utf-8');
+    const versionMatch = mcpContent.match(/## Version\s+(\d+\.\d+\.\d+)/);
+    if (versionMatch && versionMatch[1] !== version) {
+      drifted.push({ file: mcpSubmPath, field: 'version-heading', current: versionMatch[1] });
+      if (!checkOnly) {
+        replaceInFile(mcpSubmPath, versionMatch[1], version);
+      }
+    }
+    targets.push(mcpSubmPath);
+  }
+
+  return {
+    version,
+    targets,
+    drifted,
+    synced: !checkOnly && drifted.length > 0,
+    allInSync: drifted.length === 0,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const checkOnly = process.argv.includes('--check');
+  const result = syncVersion({ check: checkOnly });
+
+  if (result.allInSync) {
+    console.log(`✔ All ${result.targets.length} targets in sync at v${result.version}`);
+    process.exit(0);
+  }
+
+  if (checkOnly) {
+    console.error(`✖ Version drift detected (package.json = ${result.version}):`);
+    result.drifted.forEach((d) => {
+      console.error(`  ${d.file} [${d.field}] = ${d.current}`);
+    });
+    process.exit(1);
+  }
+
+  console.log(`✔ Synced ${result.drifted.length} targets to v${result.version}:`);
+  result.drifted.forEach((d) => {
+    console.log(`  ${d.file} [${d.field}]: ${d.current} → ${result.version}`);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { syncVersion };

package/scripts/test-coverage.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const TESTS_DIR = path.join(PROJECT_ROOT, 'tests');
+
+function findCoverageTestFiles({
+  dir = TESTS_DIR,
+  projectRoot = PROJECT_ROOT,
+} = {}) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findCoverageTestFiles({ dir: fullPath, projectRoot }));
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith('.test.js')) {
+      files.push(path.relative(projectRoot, fullPath));
+    }
+  }
+
+  return files.sort();
+}
+
+function buildCoverageArgs(files) {
+  return ['--test', '--test-concurrency=1', '--experimental-test-coverage', ...files];
+}
+
+function runCoverage({
+  files = findCoverageTestFiles(),
+  cwd = PROJECT_ROOT,
+  spawn = spawnSync,
+} = {}) {
+  if (files.length === 0) {
+    return {
+      exitCode: 1,
+      error: 'No test files found for coverage run.',
+      args: buildCoverageArgs(files),
+    };
+  }
+
+  const args = buildCoverageArgs(files);
+  const result = spawn(process.execPath, args, {
+    cwd,
+    env: process.env,
+    stdio: 'inherit',
+  });
+
+  return {
+    exitCode: Number.isInteger(result.status) ? result.status : 1,
+    error: result.error ? result.error.message : null,
+    args,
+  };
+}
+
+if (require.main === module) {
+  const result = runCoverage();
+  if (result.error) {
+    console.error(result.error);
+  }
+  process.exit(result.exitCode);
+}
+
+module.exports = {
+  PROJECT_ROOT,
+  TESTS_DIR,
+  findCoverageTestFiles,
+  buildCoverageArgs,
+  runCoverage,
+};

package/scripts/validate-workflow-contract.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const WORKFLOW_PATH = path.join(PROJECT_ROOT, 'WORKFLOW.md');
+const ISSUE_TEMPLATE_PATH = path.join(PROJECT_ROOT, '.github', 'ISSUE_TEMPLATE', 'ready-for-agent.yml');
+const PR_TEMPLATE_PATH = path.join(PROJECT_ROOT, '.github', 'pull_request_template.md');
+const README_PATH = path.join(PROJECT_ROOT, 'README.md');
+
+const REQUIRED_WORKFLOW_HEADINGS = [
+  '## Scope',
+  '## Hard Stops',
+  '## Required Proof of Work',
+  '## Implementation Rules',
+  '## Done Means',
+  '## Handoff Format',
+];
+
+const REQUIRED_PROOF_COMMANDS = [
+  'npm test',
+  'npm run test:coverage',
+  'npm run prove:adapters',
+  'npm run prove:automation',
+  'npm run self-heal:check',
+];
+
+const REQUIRED_ISSUE_FIELDS = [
+  'business_outcome',
+  'problem',
+  'in_scope',
+  'out_of_scope',
+  'acceptance_criteria',
+  'proof_commands',
+];
+
+const REQUIRED_PR_SECTIONS = [
+  '## What Changed',
+  '## Why',
+  '## Verification',
+  '## Evidence',
+  '## Risks',
+];
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function extractFrontMatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return {
+      ok: false,
+      frontMatter: '',
+      body: '',
+      error: 'WORKFLOW.md must start with YAML front matter wrapped in --- markers.',
+    };
+  }
+
+  return {
+    ok: true,
+    frontMatter: match[1],
+    body: match[2].trim(),
+    error: null,
+  };
+}
+
+function hasLine(text, pattern) {
+  return pattern.test(text);
+}
+
+function collectMatches(text, entries, matcher) {
+  return entries.filter((entry) => matcher(text, entry));
+}
+
+function validateWorkflowFile(text) {
+  const issues = [];
+  const extracted = extractFrontMatter(text);
+  const result = {
+    headingsFound: [],
+    proofCommandsFound: [],
+  };
+
+  if (!extracted.ok) {
+    issues.push(extracted.error);
+    return { issues, details: result };
+  }
+
+  const frontMatter = extracted.frontMatter;
+  const body = extracted.body;
+
+  const requiredFrontMatterPatterns = [
+    { label: 'tracker block', pattern: /^tracker:\s*$/m },
+    { label: 'linear tracker kind', pattern: /^\s*kind:\s*linear\s*$/m },
+    { label: 'project_slug', pattern: /^\s*project_slug:\s*.+$/m },
+    { label: 'workspace block', pattern: /^workspace:\s*$/m },
+    { label: 'workspace root', pattern: /^\s*root:\s*.+$/m },
+    { label: 'hooks block', pattern: /^hooks:\s*$/m },
+    { label: 'after_create hook', pattern: /^\s*after_create:\s*\|/m },
+    { label: 'before_run hook', pattern: /^\s*before_run:\s*\|/m },
+    { label: 'after_run hook', pattern: /^\s*after_run:\s*\|/m },
+    { label: 'agent block', pattern: /^agent:\s*$/m },
+    { label: 'max_concurrent_agents', pattern: /^\s*max_concurrent_agents:\s*\d+/m },
+    { label: 'max_turns', pattern: /^\s*max_turns:\s*\d+/m },
+    { label: 'codex block', pattern: /^codex:\s*$/m },
+    { label: 'codex command', pattern: /^\s*command:\s*['"]?codex app-server['"]?\s*$/m },
+  ];
+
+  for (const entry of requiredFrontMatterPatterns) {
+    if (!hasLine(frontMatter, entry.pattern)) {
+      issues.push(`WORKFLOW.md is missing ${entry.label} in front matter.`);
+    }
+  }
+
+  result.headingsFound = collectMatches(body, REQUIRED_WORKFLOW_HEADINGS, (value, heading) => value.includes(heading));
+  for (const heading of REQUIRED_WORKFLOW_HEADINGS) {
+    if (!body.includes(heading)) {
+      issues.push(`WORKFLOW.md body is missing required heading "${heading}".`);
+    }
+  }
+
+  result.proofCommandsFound = collectMatches(body, REQUIRED_PROOF_COMMANDS, (value, command) => value.includes(command));
+  for (const command of REQUIRED_PROOF_COMMANDS) {
+    if (!body.includes(command)) {
+      issues.push(`WORKFLOW.md proof section is missing "${command}".`);
+    }
+  }
+
+  if (!body.includes('no dead code')) {
+    issues.push('WORKFLOW.md must explicitly ban dead code.');
+  }
+
+  if (!body.includes('docs/VERIFICATION_EVIDENCE.md')) {
+    issues.push('WORKFLOW.md must require updates to docs/VERIFICATION_EVIDENCE.md for behavior changes.');
+  }
+
+  return { issues, details: result };
+}
+
+function validateIssueTemplateFile(text) {
+  const issues = [];
+  const result = {
+    fieldIdsFound: collectMatches(text, REQUIRED_ISSUE_FIELDS, (value, fieldId) => value.includes(`id: ${fieldId}`)),
+  };
+
+  if (!text.includes('name: Ready for Agent')) {
+    issues.push('ready-for-agent issue template must be named "Ready for Agent".');
+  }
+
+  for (const fieldId of REQUIRED_ISSUE_FIELDS) {
+    if (!text.includes(`id: ${fieldId}`)) {
+      issues.push(`ready-for-agent issue template is missing field id "${fieldId}".`);
+    }
+  }
+
+  for (const command of REQUIRED_PROOF_COMMANDS) {
+    if (!text.includes(command)) {
+      issues.push(`ready-for-agent issue template must include proof command "${command}".`);
+    }
+  }
+
+  return { issues, details: result };
+}
+
+function validatePullRequestTemplateFile(text) {
+  const issues = [];
+  const result = {
+    sectionsFound: collectMatches(text, REQUIRED_PR_SECTIONS, (value, section) => value.includes(section)),
+  };
+
+  for (const section of REQUIRED_PR_SECTIONS) {
+    if (!text.includes(section)) {
+      issues.push(`pull request template is missing section "${section}".`);
+    }
+  }
+
+  for (const command of REQUIRED_PROOF_COMMANDS) {
+    if (!text.includes(command)) {
+      issues.push(`pull request template must include proof command "${command}".`);
+    }
+  }
+
+  return { issues, details: result };
+}
+
+function validateReadmeFile(text) {
+  const issues = [];
+  const result = {
+    referencesWorkflow: text.includes('WORKFLOW.md'),
+    referencesReadyTemplate: text.includes('ready-for-agent'),
+  };
+
+  if (!result.referencesWorkflow) {
+    issues.push('README.md must reference WORKFLOW.md so operators can find the agent-run contract.');
+  }
+
+  if (!result.referencesReadyTemplate) {
+    issues.push('README.md must reference the ready-for-agent intake template.');
+  }
+
+  return { issues, details: result };
+}
+
+function runWorkflowContractValidation(options = {}) {
+  const projectRoot = options.projectRoot || PROJECT_ROOT;
+  const files = {
+    workflow: path.join(projectRoot, 'WORKFLOW.md'),
+    issueTemplate: path.join(projectRoot, '.github', 'ISSUE_TEMPLATE', 'ready-for-agent.yml'),
+    pullRequestTemplate: path.join(projectRoot, '.github', 'pull_request_template.md'),
+    readme: path.join(projectRoot, 'README.md'),
+  };
+  const issues = [];
+  const details = {};
+
+  const validators = [
+    ['workflow', validateWorkflowFile],
+    ['issueTemplate', validateIssueTemplateFile],
+    ['pullRequestTemplate', validatePullRequestTemplateFile],
+    ['readme', validateReadmeFile],
+  ];
+
+  for (const [key, validator] of validators) {
+    if (!fs.existsSync(files[key])) {
+      issues.push(`${path.relative(projectRoot, files[key])} is missing.`);
+      details[key] = {};
+      continue;
+    }
+
+    const text = readText(files[key]);
+    const validation = validator(text);
+    details[key] = validation.details;
+    issues.push(...validation.issues);
+  }
+
+  return {
+    ok: issues.length === 0,
+    generatedAt: new Date().toISOString(),
+    files: {
+      workflow: path.relative(projectRoot, files.workflow),
+      issueTemplate: path.relative(projectRoot, files.issueTemplate),
+      pullRequestTemplate: path.relative(projectRoot, files.pullRequestTemplate),
+      readme: path.relative(projectRoot, files.readme),
+    },
+    requiredProofCommands: REQUIRED_PROOF_COMMANDS.slice(),
+    details,
+    issues,
+  };
+}
+
+function printResult(result, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (result.ok) {
+    console.log('Workflow contract validation passed.');
+    console.log(`Validated: ${Object.values(result.files).join(', ')}`);
+    return;
+  }
+
+  console.error('Workflow contract validation failed:');
+  result.issues.forEach((issue) => {
+    console.error(`- ${issue}`);
+  });
+}
+
+if (require.main === module) {
+  const asJson = process.argv.includes('--json');
+  const result = runWorkflowContractValidation();
+  printResult(result, asJson);
+  process.exit(result.ok ? 0 : 1);
+}
+
+module.exports = {
+  PROJECT_ROOT,
+  REQUIRED_ISSUE_FIELDS,
+  REQUIRED_PR_SECTIONS,
+  REQUIRED_PROOF_COMMANDS,
+  REQUIRED_WORKFLOW_HEADINGS,
+  extractFrontMatter,
+  runWorkflowContractValidation,
+  validateIssueTemplateFile,
+  validatePullRequestTemplateFile,
+  validateReadmeFile,
+  validateWorkflowFile,
+};

package/scripts/vector-store.js

@@ -1,31 +1,100 @@
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
+const {
+  resolveEmbeddingProfile,
+  writeModelFitReport,
+  resolveFeedbackDir,
+} = require('./local-model-profile');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_LANCE_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback', 'lancedb');
+const DEFAULT_FEEDBACK_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const DEFAULT_LANCE_DIR = path.join(DEFAULT_FEEDBACK_DIR, 'lancedb');
 
 // Module-level cache — prevents re-importing on every upsertFeedback() call
 // First ESM import takes ~200ms; second is instant from cache.
 let _lancedb = null;
-let _pipeline = null;
+let _lancedbLoader = null;
+const _pipelineCache = new Map();
+let _lastEmbeddingProfile = null;
+let _pipelineLoader = null;
 const TABLE_NAME = 'rlhf_memories';
 
 async function getLanceDB() {
   if (!_lancedb) {
-    _lancedb = await import('@lancedb/lancedb');
+    _lancedb = _lancedbLoader ? await _lancedbLoader() : await import('@lancedb/lancedb');
   }
   return _lancedb;
 }
 
+function getFeedbackDir() {
+  return resolveFeedbackDir(process.env.RLHF_FEEDBACK_DIR || DEFAULT_FEEDBACK_DIR);
+}
+
+function getLanceDir() {
+  return path.join(getFeedbackDir(), 'lancedb');
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function truncateForEmbedding(text, maxChars) {
+  const raw = String(text || '');
+  if (!maxChars || raw.length <= maxChars) return raw;
+  return raw.slice(0, maxChars);
+}
+
+async function loadPipelineForProfile(profile) {
+  const cacheKey = `${profile.model}::${profile.quantized}`;
+  if (_pipelineCache.has(cacheKey)) {
+    return _pipelineCache.get(cacheKey);
+  }
+
+  if (process.env.RLHF_VECTOR_FORCE_PRIMARY_FAILURE === 'true' && profile.id !== 'fallback') {
+    throw new Error('Forced primary embedding profile failure');
+  }
+
+  const pipeline = _pipelineLoader || (await import('@huggingface/transformers')).pipeline;
+  const pipe = await pipeline('feature-extraction', profile.model, {
+    quantized: profile.quantized,
+  });
+  _pipelineCache.set(cacheKey, pipe);
+  return pipe;
+}
+
 async function getEmbeddingPipeline() {
-  if (!_pipeline) {
-    const { pipeline } = await import('@huggingface/transformers');
-    _pipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
-      quantized: true,
+  const resolved = resolveEmbeddingProfile();
+  const report = writeModelFitReport(getFeedbackDir(), { resolved }).report;
+
+  try {
+    const pipe = await loadPipelineForProfile(resolved.selectedProfile);
+    _lastEmbeddingProfile = {
+      ...report,
+      activeProfile: resolved.selectedProfile,
+      fallbackUsed: false,
+    };
+    return { pipe, profile: _lastEmbeddingProfile };
+  } catch (primaryError) {
+    const fallback = resolved.fallbackProfile;
+    const pipe = await loadPipelineForProfile(fallback);
+    _lastEmbeddingProfile = {
+      ...report,
+      activeProfile: fallback,
+      fallbackUsed: true,
+      fallbackReason: primaryError.message,
+    };
+    writeModelFitReport(getFeedbackDir(), {
+      resolved: {
+        ...resolved,
+        selectedProfile: fallback,
+      },
     });
+    return { pipe, profile: _lastEmbeddingProfile };
   }
-  return _pipeline;
 }
 
 // Stub embed support for unit tests — avoids HuggingFace ONNX model download.
@@ -39,15 +108,17 @@ async function embed(text) {
     stub[0] = 1.0;
     return stub;
   }
-  const pipe = await getEmbeddingPipeline();
-  const output = await pipe(text, { pooling: 'mean', normalize: true });
+  const { pipe, profile } = await getEmbeddingPipeline();
+  const output = await pipe(truncateForEmbedding(text, profile.activeProfile.maxChars), {
+    pooling: 'mean',
+    normalize: true,
+  });
   return Array.from(output.data); // Float32Array -> plain number[] for LanceDB Arrow serialization
 }
 
 async function upsertFeedback(feedbackEvent) {
-  const lanceDir = process.env.RLHF_FEEDBACK_DIR
-    ? path.join(process.env.RLHF_FEEDBACK_DIR, 'lancedb')
-    : DEFAULT_LANCE_DIR;
+  const lanceDir = getLanceDir();
+  ensureDir(lanceDir);
 
   const { connect } = await getLanceDB();
   const db = await connect(lanceDir);
@@ -81,9 +152,8 @@ async function upsertFeedback(feedbackEvent) {
 }
 
 async function searchSimilar(queryText, limit = 5) {
-  const lanceDir = process.env.RLHF_FEEDBACK_DIR
-    ? path.join(process.env.RLHF_FEEDBACK_DIR, 'lancedb')
-    : DEFAULT_LANCE_DIR;
+  const lanceDir = getLanceDir();
+  ensureDir(lanceDir);
 
   const { connect } = await getLanceDB();
   const db = await connect(lanceDir);
@@ -97,4 +167,32 @@ async function searchSimilar(queryText, limit = 5) {
   return results;
 }
 
-module.exports = { upsertFeedback, searchSimilar, TABLE_NAME };
+function getEmbeddingConfig() {
+  return resolveEmbeddingProfile();
+}
+
+function getLastEmbeddingProfile() {
+  return _lastEmbeddingProfile;
+}
+
+function setPipelineLoaderForTests(loader) {
+  _pipelineLoader = loader;
+  _pipelineCache.clear();
+  _lastEmbeddingProfile = null;
+}
+
+function setLanceLoaderForTests(loader) {
+  _lancedbLoader = loader;
+  _lancedb = null;
+}
+
+module.exports = {
+  upsertFeedback,
+  searchSimilar,
+  TABLE_NAME,
+  getEmbeddingConfig,
+  getLastEmbeddingProfile,
+  setPipelineLoaderForTests,
+  setLanceLoaderForTests,
+  truncateForEmbedding,
+};