@nzpr/kb 0.1.0

package/lib/cli.js

@@ -0,0 +1,391 @@
+import path from "node:path";
+import {
+  resolveDocsRoot,
+  resolveEmbeddingProfile,
+  resolveDatabaseUrl,
+  resolveGitHubApiBaseUrl,
+  resolveGitHubRepository,
+  tryResolveKnowledgeRoot
+} from "./config.js";
+import { connect, initDb } from "./db.js";
+import { ingestDocuments } from "./index.js";
+import { createGitHubIssueFromText } from "./kb-proposals.js";
+import { bootstrapKnowledgeRepo } from "./repo-init.js";
+import { askIndex, doctor, knowledgeCatalog, listDocuments, searchIndex, snippet } from "./search.js";
+import {
+  databaseHelp,
+  formatCliError,
+  githubCreationHelp,
+  maskConnection,
+  parseFlags,
+  publishHelp
+} from "./cli-common.js";
+
+export async function main(argv) {
+  try {
+    const [command, ...rest] = argv;
+    if (!command || command === "--help" || command === "-h") {
+      printHelp();
+      return 0;
+    }
+    if (rest.includes("--help") || rest.includes("-h")) {
+      printCommandHelp(command);
+      return 0;
+    }
+
+    const { flags, positional } = parseFlags(rest);
+
+    switch (command) {
+      case "create": {
+        const title = String(flags.title ?? "").trim();
+        const text = String(flags.text ?? "").trim();
+        const repo = flags.repo ?? resolveGitHubRepository();
+        if (!title) {
+          console.error("--title is required");
+          return 2;
+        }
+        if (!text) {
+          console.error("--text is required");
+          return 2;
+        }
+        const issue = await createGitHubIssueFromText({
+          title,
+          text,
+          relativePath: flags.path ?? null,
+          repo,
+          token: process.env.GITHUB_TOKEN ?? null,
+          apiBaseUrl: resolveGitHubApiBaseUrl()
+        });
+        console.log(`created KB proposal issue #${issue.number}: ${issue.html_url}`);
+        return 0;
+      }
+      case "init-repo": {
+        const result = await bootstrapKnowledgeRepo({
+          targetDir: flags.dir ?? process.cwd(),
+          repo: flags.repo ?? resolveGitHubRepository(),
+          githubToken: process.env.GITHUB_TOKEN ?? null,
+          databaseUrl: flags["database-url"] ?? process.env.KB_DATABASE_URL ?? null,
+          embeddingMode: flags["embedding-mode"] ?? process.env.KB_EMBEDDING_MODE ?? null,
+          embeddingApiUrl: flags["embedding-api-url"] ?? process.env.KB_EMBEDDING_API_URL ?? null,
+          embeddingModel: flags["embedding-model"] ?? process.env.KB_EMBEDDING_MODEL ?? null,
+          embeddingApiKey: flags["embedding-api-key"] ?? process.env.KB_EMBEDDING_API_KEY ?? null,
+          dbConnectTimeoutMs:
+            flags["db-connect-timeout-ms"] ?? process.env.KB_DB_CONNECT_TIMEOUT_MS ?? null,
+          repoAutomationToken:
+            flags["repo-automation-token"] ?? process.env.KB_REPO_AUTOMATION_TOKEN ?? null
+        });
+        console.log(`initialized knowledge repo scaffold in ${result.root}`);
+        for (const relativePath of result.created) {
+          console.log(`created ${relativePath}`);
+        }
+        for (const relativePath of result.skipped) {
+          console.log(`kept existing ${relativePath}`);
+        }
+        if (!result.created.length) {
+          console.log("no files created");
+        }
+        printInitRepoStatus(result);
+        printRepoConfiguration(result.configuration);
+        printInitRepoNextStep(result);
+        return result.ok ? 0 : 1;
+      }
+      case "search": {
+        const databaseUrl = requireDatabaseUrl();
+        const embeddingProfile = resolveEmbeddingProfile();
+        const query = positional.join(" ").trim();
+        if (!query) {
+          console.error("search query is required");
+          return 2;
+        }
+        const results = await searchIndex({
+          databaseUrl,
+          embeddingProfile,
+          query,
+          limit: Number(flags.limit ?? 5)
+        });
+        for (const result of results) {
+          console.log(result.title);
+          console.log(`  ${snippet(result.content)}`);
+          console.log(`  Source: ${result.path} | score=${result.finalScore.toFixed(3)}`);
+        }
+        return results.length ? 0 : 1;
+      }
+      case "ask": {
+        const databaseUrl = requireDatabaseUrl();
+        const embeddingProfile = resolveEmbeddingProfile();
+        const query = positional.join(" ").trim();
+        if (!query) {
+          console.error("question is required");
+          return 2;
+        }
+        const { answer, results } = await askIndex({
+          databaseUrl,
+          embeddingProfile,
+          query,
+          limit: Number(flags.limit ?? 3)
+        });
+        console.log(answer);
+        return results.length ? 0 : 1;
+      }
+      case "list": {
+        const databaseUrl = requireDatabaseUrl();
+        const rows = await listDocuments({ databaseUrl });
+        for (const row of rows) {
+          console.log(`${row.doc_id}\t${row.path}\t${row.title}`);
+        }
+        return 0;
+      }
+      case "catalog": {
+        const databaseUrl = requireDatabaseUrl();
+        const catalog = await knowledgeCatalog({ databaseUrl });
+        if (flags.json) {
+          console.log(JSON.stringify(catalog, null, 2));
+          return 0;
+        }
+        console.log("Documents:");
+        for (const doc of catalog.documents) {
+          console.log(`- ${doc.doc_id} | ${doc.path} | ${doc.title}`);
+        }
+        return 0;
+      }
+      case "publish": {
+        const repo = flags.repo ?? resolveGitHubRepository();
+        const apiBaseUrl = resolveGitHubApiBaseUrl();
+        const token = process.env.GITHUB_TOKEN ?? null;
+        await requirePublishAccess({
+          repo,
+          token,
+          apiBaseUrl
+        });
+        const knowledgeRoot = flags["knowledge-root"]
+          ? path.resolve(flags["knowledge-root"])
+          : tryResolveKnowledgeRoot();
+        const docsRoot = resolveDocsRoot({
+          docsRoot: flags["docs-root"] ?? null,
+          knowledgeRoot
+        });
+        if (!docsRoot) {
+          console.error("--docs-root PATH is required when no local docs directory is present");
+          return 2;
+        }
+        const databaseUrl = requireDatabaseUrl();
+        const embeddingProfile = resolveEmbeddingProfile();
+        const client = await connect(databaseUrl);
+        try {
+          await initDb(client);
+        } finally {
+          await client.end();
+        }
+        const result = await ingestDocuments({ databaseUrl, docsRoot, embeddingProfile });
+        console.log(
+          `published ${result.documents} documents, wrote ${result.vectors} vectors using ${result.embeddingMode}${result.embeddingModel ? `/${result.embeddingModel}` : ""} embeddings`
+        );
+        return 0;
+      }
+      case "doctor": {
+        const knowledgeRoot = flags["knowledge-root"]
+          ? path.resolve(flags["knowledge-root"])
+          : tryResolveKnowledgeRoot();
+        const docsRoot = resolveDocsRoot({
+          docsRoot: flags["docs-root"] ?? null,
+          knowledgeRoot
+        });
+        const databaseUrl = requireDatabaseUrl();
+        const embeddingProfile = resolveEmbeddingProfile();
+        const info = await doctor({ databaseUrl, embeddingProfile });
+        console.log(`database: ${maskConnection(databaseUrl)}`);
+        if (knowledgeRoot) {
+          console.log(`knowledge root: ${knowledgeRoot}`);
+        }
+        if (docsRoot) {
+          console.log(`docs root: ${docsRoot}`);
+        }
+        console.log(`database reachable: ${info.ok ? "yes" : "no"}`);
+        if (!info.ok) {
+          console.log(`error: ${info.error}`);
+          return 1;
+        }
+        console.log(`schema current: ${info.schemaCurrent}`);
+        console.log(`schema latest: ${info.schemaLatest}`);
+        console.log(`schema pending: ${info.schemaPending}`);
+        console.log(`documents: ${info.documents}`);
+        console.log(`vectors: ${info.vectors}`);
+        console.log(`embedding mode: ${info.embeddingMode}`);
+        if (info.embeddingModel) {
+          console.log(`embedding model: ${info.embeddingModel}`);
+        }
+        console.log(`embedding dimensions: ${info.embeddingDimensions}`);
+        return 0;
+      }
+      default:
+        console.error(`unknown command: ${command}`);
+        return 2;
+    }
+  } catch (error) {
+    console.error(formatCliError(error));
+    return 1;
+  }
+}
+
+function printHelp() {
+  console.log(`usage: kb <command> [options]
+
+commands:
+  init-repo [--dir PATH] [--repo OWNER/REPO]
+  create --title TEXT --text TEXT [--path RELATIVE_PATH]
+  search <query>
+  ask <question>
+  list
+  catalog [--json]
+  publish [--docs-root PATH] [--repo OWNER/REPO]
+
+${databaseHelp()}
+
+${githubCreationHelp()}
+
+${publishHelp()}
+
+optional path hint:
+  --knowledge-root PATH
+
+search options:
+  --limit N
+`);
+}
+
+function printCommandHelp(command) {
+  const commandHelp = {
+    "init-repo":
+      "usage: kb init-repo [--dir PATH] [--repo OWNER/REPO] [--database-url URL] [--embedding-mode MODE] [--embedding-api-url URL] [--embedding-model NAME] [--embedding-api-key KEY] [--db-connect-timeout-ms N] [--repo-automation-token TOKEN]\n\nScaffold a knowledge-authority repository, optionally configure its GitHub settings, and preflight the target database.",
+    create: `usage: kb create --title TEXT --text TEXT [--path RELATIVE_PATH] [--repo OWNER/REPO]\n\n${githubCreationHelp()}`,
+    search: `usage: kb search <query> [options]\n\n${databaseHelp()}\n  --limit N`,
+    ask: `usage: kb ask <question> [options]\n\n${databaseHelp()}\n  --limit N`,
+    list: `usage: kb list\n\n${databaseHelp()}`,
+    catalog: `usage: kb catalog [--json]\n\n${databaseHelp()}`,
+    publish: `usage: kb publish [--docs-root PATH] [--knowledge-root PATH] [--repo OWNER/REPO]\n\n${databaseHelp()}\n\n${publishHelp()}`,
+    doctor: `usage: kb doctor [--knowledge-root PATH] [--docs-root PATH]\n\n${databaseHelp()}`
+  };
+  console.log(commandHelp[command] ?? `unknown command: ${command}`);
+}
+
+function requireDatabaseUrl() {
+  const databaseUrl = resolveDatabaseUrl();
+  if (!databaseUrl) {
+    throw new Error("KB_DATABASE_URL is not set");
+  }
+  return databaseUrl;
+}
+
+async function requirePublishAccess({ repo, token, apiBaseUrl }) {
+  if (!repo) {
+    throw new Error("KB_GITHUB_REPO or --repo OWNER/REPO is required to publish knowledge");
+  }
+  if (!token) {
+    throw new Error("GITHUB_TOKEN is required to publish knowledge");
+  }
+
+  const response = await fetch(`${apiBaseUrl.replace(/\/$/, "")}/repos/${repo}`, {
+    headers: {
+      accept: "application/vnd.github+json",
+      authorization: `Bearer ${token}`,
+      "user-agent": "@nzpr/kb"
+    }
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(
+      `failed to verify GitHub repo access: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`
+    );
+  }
+
+  const payload = await response.json();
+  const permissions = payload?.permissions ?? null;
+  if (!permissions) {
+    return;
+  }
+  if (permissions.admin || permissions.maintain || permissions.push) {
+    return;
+  }
+  throw new Error(`GITHUB_TOKEN does not have write access to ${repo}`);
+}
+
+function printRepoConfiguration(configuration) {
+  console.log("");
+  console.log("configure the knowledge repo with these GitHub settings:");
+  console.log("");
+  console.log("required secrets:");
+  for (const entry of configuration.requiredSecrets) {
+    console.log(`  ${entry.name} - ${entry.purpose}`);
+  }
+  console.log("");
+  console.log("optional secrets:");
+  for (const entry of configuration.optionalSecrets) {
+    console.log(`  ${entry.name} - ${entry.purpose}`);
+  }
+  console.log("");
+  console.log("optional variables:");
+  for (const entry of configuration.optionalVariables) {
+    console.log(`  ${entry.name}=${entry.value} - ${entry.purpose}`);
+  }
+  console.log("");
+  console.log("publish workflow auth:");
+  console.log("  KB_GITHUB_REPO is set automatically to github.repository in the scaffolded workflow");
+  console.log("  GITHUB_TOKEN is provided automatically by GitHub Actions and must have contents:write")
+}
+
+function printInitRepoStatus(result) {
+  console.log("");
+  console.log("bootstrap status:");
+  printInitRepoDatabaseStatus(result.database);
+  printInitRepoGitHubStatus(result.github);
+}
+
+function printInitRepoDatabaseStatus(database) {
+  if (database.status === "verified") {
+    console.log(
+      `  database: verified ${database.database} current=${database.currentVersion} applied=${database.appliedCount}`
+    );
+    return;
+  }
+  if (database.status === "failed") {
+    console.log(`  database: failed - ${formatCliError(new Error(database.error))}`);
+    return;
+  }
+  console.log(`  database: pending - ${database.message}`);
+}
+
+function printInitRepoGitHubStatus(github) {
+  if (github.status === "configured") {
+    console.log(`  github: configured ${github.repo}`);
+    console.log(`  labels: ${github.labels.join(", ")}`);
+    if (github.secrets.length) {
+      console.log(`  secrets: ${github.secrets.join(", ")}`);
+    }
+    if (github.variables.length) {
+      console.log(`  variables: ${github.variables.join(", ")}`);
+    }
+    return;
+  }
+  if (github.status === "failed") {
+    console.log(`  github: failed - ${github.error}`);
+    return;
+  }
+  console.log(`  github: ${github.status} - ${github.message}`);
+}
+
+function printInitRepoNextStep(result) {
+  if (!result.ok) {
+    console.log(
+      "next: fix the failed bootstrap step and rerun kb init-repo; rerunning is safe because the scaffold is idempotent"
+    );
+    return;
+  }
+  if (result.database.status === "verified" && result.github.status === "configured") {
+    console.log("next: commit the scaffold in the knowledge repo, push it, and let that repo own KB publishing");
+    return;
+  }
+  console.log(
+    "next: rerun kb init-repo with the missing repo or database inputs when you are ready, or commit the scaffold now and finish remote setup later"
+  );
+}

package/lib/config.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+const LOCAL_HASH_PROFILE = Object.freeze({
+  mode: "local-hash",
+  model: null,
+  dimensions: 256,
+  apiUrl: null,
+  apiKey: null,
+  timeoutMs: 0
+});
+
+export function tryResolveKnowledgeRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(current, "kb", "docs"))) {
+      return path.join(current, "kb");
+    }
+    if (fs.existsSync(path.join(current, "knowledge", "docs"))) {
+      return path.join(current, "knowledge");
+    }
+    if (
+      fs.existsSync(path.join(current, "docs")) &&
+      fs.existsSync(path.join(current, "package.json"))
+    ) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+export function resolveDocsRoot({ docsRoot = null, knowledgeRoot = null, cwd = process.cwd() } = {}) {
+  if (docsRoot) {
+    return path.resolve(docsRoot);
+  }
+  if (knowledgeRoot) {
+    return path.join(knowledgeRoot, "docs");
+  }
+  const cwdKbDocsRoot = path.resolve(cwd, "kb", "docs");
+  if (fs.existsSync(cwdKbDocsRoot)) {
+    return cwdKbDocsRoot;
+  }
+  const cwdDocsRoot = path.resolve(cwd, "docs");
+  if (fs.existsSync(cwdDocsRoot)) {
+    return cwdDocsRoot;
+  }
+  return null;
+}
+
+export function resolveDatabaseUrl() {
+  return process.env.KB_DATABASE_URL ?? null;
+}
+
+export function resolveGitHubRepository(env = process.env) {
+  return env.KB_GITHUB_REPO ?? env.GITHUB_REPOSITORY ?? null;
+}
+
+export function resolveGitHubApiBaseUrl(env = process.env) {
+  return env.GITHUB_API_URL ?? "https://api.github.com";
+}
+
+export function resolveEmbeddingProfile(env = process.env) {
+  const mode = normalizeEmbeddingMode(env.KB_EMBEDDING_MODE ?? LOCAL_HASH_PROFILE.mode);
+  if (mode === LOCAL_HASH_PROFILE.mode) {
+    return { ...LOCAL_HASH_PROFILE };
+  }
+  if (mode !== "bge-m3-openai") {
+    throw new Error(`unsupported KB_EMBEDDING_MODE: ${mode}`);
+  }
+
+  const rawApiUrl = env.KB_EMBEDDING_API_URL ?? null;
+  if (!rawApiUrl) {
+    throw new Error("KB_EMBEDDING_API_URL is required when KB_EMBEDDING_MODE=bge-m3-openai");
+  }
+
+  const timeoutMs = Number(env.KB_EMBEDDING_TIMEOUT_MS ?? 30000);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("KB_EMBEDDING_TIMEOUT_MS must be a positive number");
+  }
+
+  return {
+    mode,
+    model: env.KB_EMBEDDING_MODEL ?? "BAAI/bge-m3",
+    dimensions: 1024,
+    apiUrl: normalizeEmbeddingApiUrl(rawApiUrl),
+    apiKey: env.KB_EMBEDDING_API_KEY ?? null,
+    timeoutMs
+  };
+}
+
+function normalizeEmbeddingMode(mode) {
+  if (mode === "openai") {
+    return "bge-m3-openai";
+  }
+  return mode;
+}
+
+function normalizeEmbeddingApiUrl(value) {
+  const url = new URL(value);
+  if (url.pathname === "" || url.pathname === "/") {
+    url.pathname = "/v1/embeddings";
+  } else if (url.pathname.endsWith("/v1")) {
+    url.pathname = `${url.pathname}/embeddings`;
+  }
+  return url.toString();
+}

package/lib/db.js

@@ -0,0 +1,81 @@
+import { Client } from "pg";
+import { migrateDatabase, migrationStatus } from "./migrations.js";
+
+export async function connect(databaseUrl) {
+  const client = new Client({
+    connectionString: databaseUrl,
+    connectionTimeoutMillis: Number(process.env.KB_DB_CONNECT_TIMEOUT_MS ?? 5000)
+  });
+  await client.connect();
+  return client;
+}
+
+export async function initDb(client) {
+  return migrateDatabase(client);
+}
+
+export async function schemaStatus(client) {
+  return migrationStatus(client);
+}
+
+export async function ensureCompatibility(client, embeddingProfile) {
+  const status = await migrationStatus(client);
+  if (status.pendingCount > 0) {
+    throw new Error(
+      `database schema is behind: current=${status.currentVersion} latest=${status.latestVersion}; run kb publish`
+    );
+  }
+  if (!embeddingProfile) {
+    return;
+  }
+  const values = await readEmbeddingMetadata(client);
+  if (!values.embedding_mode && !values.embedding_dim && !values.embedding_model) {
+    return;
+  }
+  if (values.embedding_dim && values.embedding_dim !== String(embeddingProfile.dimensions)) {
+    throw new Error(
+      `embedding dimension mismatch: database=${values.embedding_dim} current=${embeddingProfile.dimensions}`
+    );
+  }
+  if (values.embedding_mode && values.embedding_mode !== embeddingProfile.mode) {
+    throw new Error(
+      `embedding mode mismatch: database=${values.embedding_mode} current=${embeddingProfile.mode}`
+    );
+  }
+  if ((values.embedding_model ?? "") !== normalizeEmbeddingModel(embeddingProfile.model)) {
+    throw new Error(
+      `embedding model mismatch: database=${values.embedding_model ?? ""} current=${normalizeEmbeddingModel(
+        embeddingProfile.model
+      )}`
+    );
+  }
+}
+
+export async function readEmbeddingMetadata(client) {
+  const result = await client.query(
+    "SELECT key, value FROM kb_metadata WHERE key IN ('embedding_mode', 'embedding_dim', 'embedding_model')"
+  );
+  return Object.fromEntries(result.rows.map((row) => [row.key, row.value]));
+}
+
+export async function writeEmbeddingMetadata(client, embeddingProfile) {
+  const entries = [
+    ["embedding_mode", embeddingProfile.mode],
+    ["embedding_dim", String(embeddingProfile.dimensions)],
+    ["embedding_model", normalizeEmbeddingModel(embeddingProfile.model)]
+  ];
+  for (const [key, value] of entries) {
+    await client.query(
+      `
+      INSERT INTO kb_metadata (key, value)
+      VALUES ($1, $2)
+      ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value
+      `,
+      [key, value]
+    );
+  }
+}
+
+function normalizeEmbeddingModel(model) {
+  return model ?? "";
+}

package/lib/embeddings.js

@@ -0,0 +1,94 @@
+const TOKEN_RE = /[a-zA-Z0-9_]+/g;
+export const EMBEDDING_DIM = 256;
+
+export async function embedText(text, embeddingProfile = null) {
+  if (!embeddingProfile || embeddingProfile.mode === "local-hash") {
+    return embedTextLocal(text);
+  }
+  if (embeddingProfile.mode === "bge-m3-openai") {
+    return embedTextRemote(text, embeddingProfile);
+  }
+  throw new Error(`unsupported embedding mode: ${embeddingProfile.mode}`);
+}
+
+export function embedTextLocal(text) {
+  const tokens = (text.match(TOKEN_RE) ?? []).map((token) => token.toLowerCase());
+  const counts = new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  const vector = new Array(EMBEDDING_DIM).fill(0);
+  for (const [token, count] of counts.entries()) {
+    const index = hashToken(token) % EMBEDDING_DIM;
+    vector[index] += count;
+  }
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  if (!norm) {
+    return vector;
+  }
+  return vector.map((value) => value / norm);
+}
+
+export function vectorLiteral(values) {
+  return `[${values.map((value) => Number(value).toFixed(8)).join(",")}]`;
+}
+
+export function tokenOverlap(query, text) {
+  const queryTokens = new Set((query.match(TOKEN_RE) ?? []).map((token) => token.toLowerCase()));
+  const textTokens = new Set((text.match(TOKEN_RE) ?? []).map((token) => token.toLowerCase()));
+  if (!queryTokens.size) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const token of queryTokens) {
+    if (textTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap / queryTokens.size;
+}
+
+function hashToken(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash >>> 0);
+}
+
+async function embedTextRemote(text, embeddingProfile) {
+  const response = await fetch(embeddingProfile.apiUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(embeddingProfile.apiKey
+        ? { authorization: `Bearer ${embeddingProfile.apiKey}` }
+        : {})
+    },
+    body: JSON.stringify({
+      input: text,
+      model: embeddingProfile.model
+    }),
+    signal: AbortSignal.timeout(embeddingProfile.timeoutMs)
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `embedding request failed: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`
+    );
+  }
+
+  const payload = await response.json();
+  const embedding = payload?.data?.[0]?.embedding;
+  if (!Array.isArray(embedding)) {
+    throw new Error("embedding response did not include data[0].embedding");
+  }
+  if (embedding.length !== embeddingProfile.dimensions) {
+    throw new Error(
+      `embedding dimension mismatch from provider: expected=${embeddingProfile.dimensions} actual=${embedding.length}`
+    );
+  }
+  return embedding.map((value) => Number(value));
+}