@deployxai/dxc 0.1.0

package/dist/chunks/knowledge-Q6MHPG6I.js

@@ -0,0 +1,1248 @@
+import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
+import {
+  CONTENT_KNOWLEDGE_CHUNKER_VERSION,
+  CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
+  CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+  CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+  CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+  CONTENT_KNOWLEDGE_SCHEMA_VERSION,
+  LocalStateError,
+  contentKnowledgeImportResultSchema,
+  contentKnowledgeModelSchema,
+  contentKnowledgeRemoveResultSchema,
+  contentKnowledgeSearchModeSchema,
+  contentKnowledgeSearchResultSchema,
+  contentKnowledgeStatusResultSchema,
+  ensurePrivateDirectory,
+  ensurePrivateRegularFile,
+  readPrivateBuffer,
+  readPrivateFile,
+  writePrivateBuffer,
+  writePrivateJson
+} from "./chunk-XIHX5YAF.js";
+
+// apps/cli/src/knowledge.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { lstat, readFile, stat } from "node:fs/promises";
+import path2 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+// apps/cli/src/knowledge-embedding.ts
+import { createHash } from "node:crypto";
+import path from "node:path";
+var MODEL_MARKER_NAME = "content-embedding-model.json";
+var MODEL_BASE_URL = `https://huggingface.co/${CONTENT_KNOWLEDGE_EMBEDDING_MODEL}/resolve/${CONTENT_KNOWLEDGE_EMBEDDING_REVISION}`;
+var ONNX_RUNTIME_MODULE_NAME = "onnxruntime-web";
+var TOKENIZERS_MODULE_NAME = "@huggingface/tokenizers";
+var QUERY_INSTRUCTION = "\u4E3A\u8FD9\u4E2A\u53E5\u5B50\u751F\u6210\u8868\u793A\u4EE5\u7528\u4E8E\u68C0\u7D22\u76F8\u5173\u6587\u7AE0\uFF1A";
+var MAXIMUM_TOKENS = 512;
+var EMBEDDING_BATCH_SIZE = 8;
+var MODEL_DOWNLOAD_TIMEOUT_MS = 3e5;
+var MODEL_ARTIFACTS = [
+  {
+    maximumBytes: 25 * 1024 * 1024,
+    name: "model_quantized.onnx",
+    remotePath: "onnx/model_quantized.onnx",
+    sha256: "15b717c382bcb518ba457b93ea6850ede7f4f1cd8937454aa06972366cd19bcc"
+  },
+  {
+    maximumBytes: 512 * 1024,
+    name: "tokenizer.json",
+    remotePath: "tokenizer.json",
+    sha256: "48cea5d44424912a6fd1ea647bf4fe50b55ab8b1e5879c3275f80e339e8fae26"
+  },
+  {
+    maximumBytes: 8 * 1024,
+    name: "tokenizer_config.json",
+    remotePath: "tokenizer_config.json",
+    sha256: "e6f3b96db926a37d4039995fbf5ad17de158dfb8f6343d607e4dbaad18d75f5a"
+  }
+];
+function artifactPath(cacheDirectory, artifact) {
+  return path.join(cacheDirectory, artifact.name);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+async function readVerifiedArtifact(cacheDirectory, artifact) {
+  try {
+    const contents = await readPrivateBuffer(
+      artifactPath(cacheDirectory, artifact),
+      artifact.maximumBytes
+    );
+    if (sha256(contents) !== artifact.sha256) {
+      throw new Error("local model artifact checksum is invalid");
+    }
+    return contents;
+  } catch (error) {
+    if (error instanceof LocalStateError && error.failure === "missing") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function downloadArtifact(cacheDirectory, artifact) {
+  const response = await fetch(`${MODEL_BASE_URL}/${artifact.remotePath}`, {
+    headers: {
+      "user-agent": "dxc-cli/0.1"
+    },
+    redirect: "follow",
+    signal: AbortSignal.timeout(MODEL_DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error("local model artifact download failed");
+  }
+  const declaredSize = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredSize) && declaredSize > artifact.maximumBytes) {
+    throw new Error("local model artifact is too large");
+  }
+  const contents = Buffer.from(await response.arrayBuffer());
+  if (contents.byteLength > artifact.maximumBytes || sha256(contents) !== artifact.sha256) {
+    throw new Error("downloaded model artifact checksum is invalid");
+  }
+  await writePrivateBuffer(artifactPath(cacheDirectory, artifact), contents);
+  return contents;
+}
+async function ensureModelArtifacts(cacheDirectory) {
+  await ensurePrivateDirectory(cacheDirectory);
+  const artifacts = /* @__PURE__ */ new Map();
+  for (const artifact of MODEL_ARTIFACTS) {
+    const cached = await readVerifiedArtifact(cacheDirectory, artifact);
+    artifacts.set(artifact.name, cached ?? await downloadArtifact(cacheDirectory, artifact));
+  }
+  return artifacts;
+}
+function modelMarkerPath(cacheDirectory) {
+  return path.join(cacheDirectory, MODEL_MARKER_NAME);
+}
+function parseJsonObject(value, label) {
+  const parsed = JSON.parse(value.toString("utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${label} is invalid`);
+  }
+  return parsed;
+}
+async function loadOnnxRuntime() {
+  const loaded = await import(ONNX_RUNTIME_MODULE_NAME);
+  if (typeof loaded !== "object" || loaded === null || !("env" in loaded) || typeof loaded.env !== "object" || loaded.env === null || !("InferenceSession" in loaded) || typeof loaded.InferenceSession !== "object" && typeof loaded.InferenceSession !== "function" || loaded.InferenceSession === null || !("Tensor" in loaded) || typeof loaded.Tensor !== "function") {
+    throw new Error("ONNX runtime module is invalid");
+  }
+  return loaded;
+}
+async function loadTokenizerConstructor() {
+  const loaded = await import(TOKENIZERS_MODULE_NAME);
+  if (typeof loaded !== "object" || loaded === null || !("Tokenizer" in loaded) || typeof loaded.Tokenizer !== "function") {
+    throw new Error("tokenizer module is invalid");
+  }
+  return loaded.Tokenizer;
+}
+async function createEmbeddingRuntime(cacheDirectory) {
+  const artifacts = await ensureModelArtifacts(cacheDirectory);
+  const tokenizerJson = artifacts.get("tokenizer.json");
+  const tokenizerConfig = artifacts.get("tokenizer_config.json");
+  const model = artifacts.get("model_quantized.onnx");
+  if (tokenizerJson === void 0 || tokenizerConfig === void 0 || model === void 0) {
+    throw new Error("local model artifacts are incomplete");
+  }
+  const Tokenizer = await loadTokenizerConstructor();
+  const tokenizer = new Tokenizer(
+    parseJsonObject(tokenizerJson, "tokenizer"),
+    parseJsonObject(tokenizerConfig, "tokenizer config")
+  );
+  const onnx = await loadOnnxRuntime();
+  onnx.env.wasm.numThreads = 1;
+  const session = await onnx.InferenceSession.create(model, {
+    executionProviders: ["wasm"],
+    graphOptimizationLevel: "all"
+  });
+  if (!["input_ids", "attention_mask", "token_type_ids"].every(
+    (name) => session.inputNames.includes(name)
+  ) || !session.outputNames.includes("last_hidden_state")) {
+    await session.release();
+    throw new Error("local model input or output contract is invalid");
+  }
+  return { onnx, session, tokenizer };
+}
+function truncateEncoding(encoding, tokenizer) {
+  const tokenTypeIds = encoding.token_type_ids ?? encoding.ids.map(() => 0);
+  if (encoding.ids.length <= MAXIMUM_TOKENS) {
+    return {
+      attentionMask: encoding.attention_mask,
+      ids: encoding.ids,
+      tokenTypeIds
+    };
+  }
+  const separatorId = tokenizer.token_to_id("[SEP]");
+  if (separatorId === void 0) {
+    throw new Error("tokenizer separator token is missing");
+  }
+  const ids = encoding.ids.slice(0, MAXIMUM_TOKENS);
+  ids[MAXIMUM_TOKENS - 1] = separatorId;
+  const attentionMask = encoding.attention_mask.slice(0, MAXIMUM_TOKENS);
+  attentionMask[MAXIMUM_TOKENS - 1] = 1;
+  const truncatedTokenTypes = tokenTypeIds.slice(0, MAXIMUM_TOKENS);
+  truncatedTokenTypes[MAXIMUM_TOKENS - 1] = 0;
+  return {
+    attentionMask,
+    ids,
+    tokenTypeIds: truncatedTokenTypes
+  };
+}
+function paddedTensorData(inputs, field, sequenceLength, padId) {
+  const values = new BigInt64Array(inputs.length * sequenceLength);
+  for (const [rowIndex, input] of inputs.entries()) {
+    const row = input[field];
+    for (let columnIndex = 0; columnIndex < sequenceLength; columnIndex += 1) {
+      const fallback = field === "ids" ? padId : 0;
+      values[rowIndex * sequenceLength + columnIndex] = BigInt(row[columnIndex] ?? fallback);
+    }
+  }
+  return values;
+}
+async function embedBatch(runtime, texts) {
+  if (texts.length === 0) {
+    return [];
+  }
+  const inputs = texts.map(
+    (text) => truncateEncoding(
+      runtime.tokenizer.encode(text, { return_token_type_ids: true }),
+      runtime.tokenizer
+    )
+  );
+  const sequenceLength = Math.max(...inputs.map((input) => input.ids.length));
+  const dimensions = [inputs.length, sequenceLength];
+  const padId = runtime.tokenizer.token_to_id("[PAD]");
+  if (padId === void 0) {
+    throw new Error("tokenizer padding token is missing");
+  }
+  const output = await runtime.session.run({
+    attention_mask: new runtime.onnx.Tensor(
+      "int64",
+      paddedTensorData(inputs, "attentionMask", sequenceLength, padId),
+      dimensions
+    ),
+    input_ids: new runtime.onnx.Tensor(
+      "int64",
+      paddedTensorData(inputs, "ids", sequenceLength, padId),
+      dimensions
+    ),
+    token_type_ids: new runtime.onnx.Tensor(
+      "int64",
+      paddedTensorData(inputs, "tokenTypeIds", sequenceLength, padId),
+      dimensions
+    )
+  });
+  const tensor = output["last_hidden_state"];
+  if (tensor === void 0 || tensor.type !== "float32" || tensor.dims.length !== 3 || tensor.dims[0] !== inputs.length || tensor.dims[1] !== sequenceLength || tensor.dims[2] !== CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS) {
+    throw new Error("embedding output contract is invalid");
+  }
+  const vectors = [];
+  const rowStride = sequenceLength * CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS;
+  for (let rowIndex = 0; rowIndex < inputs.length; rowIndex += 1) {
+    const vector = new Float32Array(CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS);
+    let squaredNorm = 0;
+    const offset = rowIndex * rowStride;
+    for (let index = 0; index < vector.length; index += 1) {
+      const value = tensor.data[offset + index];
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error("embedding output contains an invalid value");
+      }
+      vector[index] = value;
+      squaredNorm += value * value;
+    }
+    const norm = Math.sqrt(squaredNorm);
+    if (!Number.isFinite(norm) || norm === 0) {
+      throw new Error("embedding output norm is invalid");
+    }
+    for (let index = 0; index < vector.length; index += 1) {
+      vector[index] = (vector[index] ?? 0) / norm;
+    }
+    vectors.push(vector);
+  }
+  return vectors;
+}
+async function isKnowledgeModelCached(cacheDirectory) {
+  try {
+    const raw = await readPrivateFile(modelMarkerPath(cacheDirectory), 16 * 1024);
+    const value = JSON.parse(raw);
+    if (!contentKnowledgeModelSchema.safeParse(value.model).success || value.runtime !== "onnxruntime-web@1.22.0" || !Array.isArray(value.artifacts) || value.artifacts.join(",") !== MODEL_ARTIFACTS.map((artifact) => artifact.sha256).join(",")) {
+      return false;
+    }
+    return (await Promise.all(
+      MODEL_ARTIFACTS.map((artifact) => readVerifiedArtifact(cacheDirectory, artifact))
+    )).every((artifact) => artifact !== void 0);
+  } catch {
+    return false;
+  }
+}
+var LocalBgeKnowledgeEmbedder = class {
+  model = contentKnowledgeModelSchema.parse({
+    dimensions: CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
+    id: CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+    quantization: CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+    revision: CONTENT_KNOWLEDGE_EMBEDDING_REVISION
+  });
+  #cacheDirectory;
+  #now;
+  #runtimePromise;
+  constructor(cacheDirectory, now = () => /* @__PURE__ */ new Date()) {
+    this.#cacheDirectory = cacheDirectory;
+    this.#now = now;
+  }
+  async #runtime() {
+    if (this.#runtimePromise === void 0) {
+      this.#runtimePromise = (async () => {
+        const runtime = await createEmbeddingRuntime(this.#cacheDirectory);
+        await writePrivateJson(modelMarkerPath(this.#cacheDirectory), {
+          artifacts: MODEL_ARTIFACTS.map((artifact) => artifact.sha256),
+          model: this.model,
+          readyAt: this.#now().toISOString(),
+          runtime: "onnxruntime-web@1.22.0"
+        });
+        return runtime;
+      })();
+    }
+    return this.#runtimePromise;
+  }
+  async embedDocuments(texts) {
+    const runtime = await this.#runtime();
+    const results = [];
+    for (let index = 0; index < texts.length; index += EMBEDDING_BATCH_SIZE) {
+      results.push(
+        ...await embedBatch(runtime, texts.slice(index, index + EMBEDDING_BATCH_SIZE))
+      );
+    }
+    return results;
+  }
+  async embedQuery(query) {
+    const runtime = await this.#runtime();
+    const [vector] = await embedBatch(runtime, [`${QUERY_INSTRUCTION}${query}`]);
+    if (vector === void 0) {
+      throw new Error("embedding output is empty");
+    }
+    return vector;
+  }
+};
+
+// apps/cli/src/knowledge.ts
+var DATABASE_DISPLAY_PATH = "~/.dxc/content-memory.sqlite";
+var MAXIMUM_ARTICLE_BYTES = 5 * 1024 * 1024;
+var MAXIMUM_CHUNK_CHARACTERS = 420;
+var TARGET_CHUNK_CHARACTERS = 280;
+var MAXIMUM_RESULTS = 20;
+var SEARCH_CANDIDATE_LIMIT = 80;
+var RRF_CONSTANT = 60;
+var SEMANTIC_MINIMUM_SIMILARITY = 0.28;
+var SEMANTIC_MAXIMUM_DISTANCE_FROM_BEST = 0.12;
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".txt"]);
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var KnowledgeCliError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "KnowledgeCliError";
+  }
+  code;
+};
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function sha2562(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function normalizedMarkdown(value) {
+  return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim();
+}
+function removeFrontmatter(value) {
+  return value.replace(/^---\n[\s\S]*?\n---(?:\n|$)/u, "");
+}
+function plainMarkdown(value) {
+  return value.replace(/<!--[\s\S]*?-->/gu, " ").replace(/!\[([^\]]*)\]\([^)]+\)/gu, "$1").replace(/\[([^\]]+)\]\([^)]+\)/gu, "$1").replace(/<[^>]+>/gu, " ").replace(/```[^\n]*\n?/gu, "").replace(/`([^`]+)`/gu, "$1").replace(/^\s{0,3}(?:[-*+]|\d+[.)])\s+/gmu, "").replace(/^\s{0,3}>\s?/gmu, "").replace(/[*_~]{1,3}/gu, "").replace(/[ \t]+/gu, " ").replace(/\n+/gu, " ").trim();
+}
+function extractTitle(value, sourceLabel) {
+  const withoutFrontmatter = removeFrontmatter(value);
+  const heading = withoutFrontmatter.match(/^\s{0,3}#\s+(.+)$/mu)?.[1];
+  const fallback = path2.basename(sourceLabel, path2.extname(sourceLabel));
+  const title = plainMarkdown(heading ?? fallback).slice(0, 300).trim();
+  if (title.length === 0) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_ARTICLE_INVALID", "Article title is empty");
+  }
+  return title;
+}
+function splitOversizedText(value) {
+  if ([...value].length <= MAXIMUM_CHUNK_CHARACTERS) {
+    return [value];
+  }
+  const sentences = value.match(/[^。！？!?；;\n]+(?:[。！？!?；;]+|$)/gu)?.map((item) => item.trim()) ?? [value];
+  const parts = [];
+  let current = "";
+  const flush = () => {
+    if (current.length > 0) {
+      parts.push(current);
+      current = "";
+    }
+  };
+  for (const sentence of sentences) {
+    if ([...sentence].length > MAXIMUM_CHUNK_CHARACTERS) {
+      flush();
+      const characters = [...sentence];
+      for (let index = 0; index < characters.length; index += MAXIMUM_CHUNK_CHARACTERS) {
+        parts.push(characters.slice(index, index + MAXIMUM_CHUNK_CHARACTERS).join(""));
+      }
+      continue;
+    }
+    const combined = current.length === 0 ? sentence : `${current} ${sentence}`;
+    if ([...combined].length > MAXIMUM_CHUNK_CHARACTERS) {
+      flush();
+      current = sentence;
+    } else {
+      current = combined;
+    }
+  }
+  flush();
+  return parts;
+}
+function chunkHistoricalArticle(markdown) {
+  const value = removeFrontmatter(markdown);
+  const lines = value.split("\n");
+  const paragraphs = [];
+  let heading = null;
+  let paragraphLines = [];
+  const flushParagraph = () => {
+    const text = plainMarkdown(paragraphLines.join("\n"));
+    paragraphLines = [];
+    if (text.length === 0) {
+      return;
+    }
+    for (const part of splitOversizedText(text)) {
+      paragraphs.push({ heading, text: part });
+    }
+  };
+  for (const line of lines) {
+    const headingMatch = line.match(/^\s{0,3}#{1,6}\s+(.+)$/u);
+    if (headingMatch !== null) {
+      flushParagraph();
+      heading = plainMarkdown(headingMatch[1] ?? "").slice(0, 300).trim() || null;
+      continue;
+    }
+    if (line.trim().length === 0) {
+      flushParagraph();
+    } else {
+      paragraphLines.push(line);
+    }
+  }
+  flushParagraph();
+  const merged = [];
+  for (const paragraph of paragraphs) {
+    const previous = merged.at(-1);
+    const combined = previous === void 0 ? paragraph.text : `${previous.body}
+
+${paragraph.text}`;
+    if (previous !== void 0 && previous.heading === paragraph.heading && [...previous.body].length < TARGET_CHUNK_CHARACTERS && [...combined].length <= MAXIMUM_CHUNK_CHARACTERS) {
+      merged[merged.length - 1] = {
+        body: combined,
+        heading: previous.heading
+      };
+    } else {
+      merged.push({
+        body: paragraph.text,
+        heading: paragraph.heading
+      });
+    }
+  }
+  return merged.map((chunk, ordinal) => ({
+    ...chunk,
+    ordinal,
+    sha256: sha2562(chunk.body)
+  }));
+}
+async function prepareArticle(currentDirectory, inputPath) {
+  const absolutePath = path2.resolve(currentDirectory, inputPath);
+  const extension = path2.extname(absolutePath).toLowerCase();
+  if (!SUPPORTED_EXTENSIONS.has(extension)) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_ARTICLE_INVALID",
+      "Only Markdown and text articles can be imported"
+    );
+  }
+  let metadata;
+  try {
+    metadata = await stat(absolutePath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_INPUT_NOT_FOUND", "Article input was not found");
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to read article input");
+  }
+  if (!metadata.isFile()) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_ARTICLE_INVALID", "Article input is invalid");
+  }
+  if (metadata.size > MAXIMUM_ARTICLE_BYTES) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_FILE_TOO_LARGE",
+      "Article input exceeds the 5 MB limit"
+    );
+  }
+  let content;
+  try {
+    content = normalizedMarkdown(await readFile(absolutePath, "utf8"));
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to read article input");
+  }
+  if (content.length === 0 || content.includes("\0")) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_ARTICLE_INVALID", "Article content is invalid");
+  }
+  const sourceLabel = path2.basename(absolutePath).slice(0, 255);
+  const chunks = chunkHistoricalArticle(content);
+  if (chunks.length === 0) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_ARTICLE_INVALID",
+      "Article has no indexable content"
+    );
+  }
+  return {
+    chunks,
+    contentSha256: sha2562(content),
+    sourceKey: sha2562(absolutePath),
+    sourceLabel,
+    title: extractTitle(content, sourceLabel)
+  };
+}
+function sqlRow(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge state is invalid");
+  }
+  return value;
+}
+function stringColumn(row, name) {
+  const value = row[name];
+  if (typeof value !== "string") {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge state is invalid");
+  }
+  return value;
+}
+function numberColumn(row, name) {
+  const value = row[name];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge state is invalid");
+  }
+  return value;
+}
+function articleRow(value) {
+  const row = sqlRow(value);
+  return {
+    chunkCount: numberColumn(row, "chunk_count"),
+    chunkerVersion: stringColumn(row, "chunker_version"),
+    contentSha256: stringColumn(row, "content_sha256"),
+    id: stringColumn(row, "id"),
+    importedAt: stringColumn(row, "imported_at"),
+    sourceLabel: stringColumn(row, "source_label"),
+    title: stringColumn(row, "title"),
+    updatedAt: stringColumn(row, "updated_at")
+  };
+}
+function articleSummary(row) {
+  return {
+    articleId: row.id,
+    chunkCount: row.chunkCount,
+    contentSha256: row.contentSha256,
+    importedAt: row.importedAt,
+    sourceLabel: row.sourceLabel,
+    title: row.title,
+    updatedAt: row.updatedAt
+  };
+}
+function vectorBuffer(vector) {
+  return Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function vectorFromColumn(value) {
+  if (value === null) {
+    return null;
+  }
+  if (!(value instanceof Uint8Array)) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge vector is invalid");
+  }
+  const expectedBytes = CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS * Float32Array.BYTES_PER_ELEMENT;
+  if (value.byteLength !== expectedBytes) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge vector is invalid");
+  }
+  return new Float32Array(Uint8Array.from(value).buffer);
+}
+function chunkRow(value) {
+  const row = sqlRow(value);
+  const headingValue = row["heading"];
+  if (headingValue !== null && typeof headingValue !== "string") {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge state is invalid");
+  }
+  return {
+    articleId: stringColumn(row, "article_id"),
+    body: stringColumn(row, "body"),
+    chunkSha256: stringColumn(row, "chunk_sha256"),
+    embedding: vectorFromColumn(row["embedding"]),
+    heading: headingValue,
+    id: stringColumn(row, "id"),
+    ordinal: numberColumn(row, "ordinal"),
+    sourceLabel: stringColumn(row, "source_label"),
+    title: stringColumn(row, "title")
+  };
+}
+function databaseSchema(database) {
+  const versionRow = sqlRow(database.prepare("PRAGMA user_version").get());
+  const version = numberColumn(versionRow, "user_version");
+  if (version !== 0 && version !== Number(CONTENT_KNOWLEDGE_SCHEMA_VERSION)) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_SCHEMA_UNSUPPORTED",
+      "Knowledge database version is unsupported"
+    );
+  }
+  database.exec(`
+    PRAGMA foreign_keys = ON;
+    PRAGMA busy_timeout = 5000;
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
+
+    CREATE TABLE IF NOT EXISTS articles (
+      id TEXT PRIMARY KEY,
+      source_key TEXT NOT NULL UNIQUE,
+      source_label TEXT NOT NULL,
+      title TEXT NOT NULL,
+      content_sha256 TEXT NOT NULL,
+      chunker_version TEXT NOT NULL,
+      imported_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      chunk_count INTEGER NOT NULL CHECK (chunk_count > 0)
+    );
+
+    CREATE INDEX IF NOT EXISTS articles_content_sha256_idx
+      ON articles(content_sha256);
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      article_id TEXT NOT NULL REFERENCES articles(id) ON DELETE CASCADE,
+      ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+      heading TEXT,
+      body TEXT NOT NULL,
+      chunk_sha256 TEXT NOT NULL,
+      embedding BLOB,
+      embedding_model TEXT,
+      embedding_revision TEXT,
+      embedding_quantization TEXT,
+      embedding_dimensions INTEGER,
+      CHECK (
+        (
+          embedding IS NULL
+          AND embedding_model IS NULL
+          AND embedding_revision IS NULL
+          AND embedding_quantization IS NULL
+          AND embedding_dimensions IS NULL
+        )
+        OR
+        (
+          embedding IS NOT NULL
+          AND embedding_model IS NOT NULL
+          AND embedding_revision IS NOT NULL
+          AND embedding_quantization IS NOT NULL
+          AND embedding_dimensions IS NOT NULL
+        )
+      ),
+      UNIQUE(article_id, ordinal)
+    );
+
+    CREATE INDEX IF NOT EXISTS chunks_article_id_idx
+      ON chunks(article_id);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunk_search USING fts5(
+      chunk_id UNINDEXED,
+      article_id UNINDEXED,
+      title,
+      heading,
+      body,
+      tokenize = 'trigram'
+    );
+
+    PRAGMA user_version = 1;
+  `);
+}
+async function openDatabase(target) {
+  try {
+    await ensurePrivateRegularFile(target);
+    const database = new DatabaseSync(target);
+    try {
+      databaseSchema(database);
+      return database;
+    } catch (error) {
+      database.close();
+      throw error;
+    }
+  } catch (error) {
+    if (error instanceof KnowledgeCliError) {
+      throw error;
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to open knowledge database");
+  }
+}
+async function databaseExists(target) {
+  try {
+    const metadata = await lstat(target);
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_STATE_INVALID", "Knowledge database is invalid");
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof KnowledgeCliError) {
+      throw error;
+    }
+    if (errorCode(error) === "ENOENT") {
+      return false;
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to inspect knowledge database");
+  }
+}
+function embeddingText(article, chunk) {
+  return [article.title.slice(0, 120), chunk.heading?.slice(0, 120) ?? "", chunk.body].filter((value) => value.length > 0).join("\n");
+}
+async function embedArticle(embedder, article) {
+  let vectors;
+  try {
+    vectors = await embedder.embedDocuments(
+      article.chunks.map((chunk) => embeddingText(article, chunk))
+    );
+  } catch {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_MODEL_FAILED",
+      "Local semantic model could not index the article"
+    );
+  }
+  if (vectors.length !== article.chunks.length || vectors.some((vector) => vector.length !== CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS)) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_MODEL_FAILED",
+      "Local semantic model returned invalid vectors"
+    );
+  }
+  return vectors;
+}
+function findExistingArticle(database, article) {
+  const statement = database.prepare(`
+    SELECT
+      id, source_label, title, content_sha256, chunker_version,
+      imported_at, updated_at, chunk_count
+    FROM articles
+    WHERE source_key = ?
+    LIMIT 1
+  `);
+  const bySource = statement.get(article.sourceKey);
+  if (bySource !== void 0) {
+    return articleRow(bySource);
+  }
+  const byContent = database.prepare(
+    `
+      SELECT
+        id, source_label, title, content_sha256, chunker_version,
+        imported_at, updated_at, chunk_count
+      FROM articles
+      WHERE content_sha256 = ?
+      ORDER BY imported_at ASC
+      LIMIT 1
+    `
+  ).get(article.contentSha256);
+  return byContent === void 0 ? void 0 : articleRow(byContent);
+}
+function semanticIndexComplete(database, articleId) {
+  const row = sqlRow(
+    database.prepare(
+      `
+        SELECT
+          COUNT(*) AS total,
+          COALESCE(SUM(
+            CASE
+              WHEN embedding IS NOT NULL
+                AND embedding_model = ?
+                AND embedding_revision = ?
+                AND embedding_quantization = ?
+                AND embedding_dimensions = ?
+              THEN 1
+              ELSE 0
+            END
+          ), 0) AS indexed
+        FROM chunks
+        WHERE article_id = ?
+      `
+    ).get(
+      CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+      CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+      CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+      CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
+      articleId
+    )
+  );
+  return numberColumn(row, "total") > 0 && numberColumn(row, "total") === numberColumn(row, "indexed");
+}
+function saveArticle(database, article, existing, vectors, timestamp, createId) {
+  const articleId = existing?.id ?? createId();
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    if (existing === void 0) {
+      database.prepare(
+        `
+          INSERT INTO articles (
+            id, source_key, source_label, title, content_sha256, chunker_version,
+            imported_at, updated_at, chunk_count
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `
+      ).run(
+        articleId,
+        article.sourceKey,
+        article.sourceLabel,
+        article.title,
+        article.contentSha256,
+        CONTENT_KNOWLEDGE_CHUNKER_VERSION,
+        timestamp,
+        timestamp,
+        article.chunks.length
+      );
+    } else {
+      database.prepare("DELETE FROM chunk_search WHERE article_id = ?").run(articleId);
+      database.prepare("DELETE FROM chunks WHERE article_id = ?").run(articleId);
+      database.prepare(
+        `
+          UPDATE articles
+          SET
+            source_key = ?,
+            source_label = ?,
+            title = ?,
+            content_sha256 = ?,
+            chunker_version = ?,
+            updated_at = ?,
+            chunk_count = ?
+          WHERE id = ?
+        `
+      ).run(
+        article.sourceKey,
+        article.sourceLabel,
+        article.title,
+        article.contentSha256,
+        CONTENT_KNOWLEDGE_CHUNKER_VERSION,
+        timestamp,
+        article.chunks.length,
+        articleId
+      );
+    }
+    const insertChunk = database.prepare(`
+      INSERT INTO chunks (
+        id, article_id, ordinal, heading, body, chunk_sha256,
+        embedding, embedding_model, embedding_revision, embedding_quantization,
+        embedding_dimensions
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertSearch = database.prepare(`
+      INSERT INTO chunk_search (chunk_id, article_id, title, heading, body)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const [index, chunk] of article.chunks.entries()) {
+      const chunkId = createId();
+      const vector = vectors?.[index];
+      insertChunk.run(
+        chunkId,
+        articleId,
+        chunk.ordinal,
+        chunk.heading,
+        chunk.body,
+        chunk.sha256,
+        vector === void 0 ? null : vectorBuffer(vector),
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+      );
+      insertSearch.run(chunkId, articleId, article.title, chunk.heading ?? "", chunk.body);
+    }
+    database.exec("COMMIT");
+  } catch (error) {
+    try {
+      database.exec("ROLLBACK");
+    } catch {
+    }
+    if (error instanceof KnowledgeCliError) {
+      throw error;
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to save article index");
+  }
+  return {
+    chunkCount: article.chunks.length,
+    chunkerVersion: CONTENT_KNOWLEDGE_CHUNKER_VERSION,
+    contentSha256: article.contentSha256,
+    id: articleId,
+    importedAt: existing?.importedAt ?? timestamp,
+    sourceLabel: article.sourceLabel,
+    title: article.title,
+    updatedAt: timestamp
+  };
+}
+function loadChunks(database) {
+  return database.prepare(
+    `
+      SELECT
+        c.id,
+        c.article_id,
+        c.ordinal,
+        c.heading,
+        c.body,
+        c.chunk_sha256,
+        CASE
+          WHEN c.embedding_model = ?
+            AND c.embedding_revision = ?
+            AND c.embedding_quantization = ?
+            AND c.embedding_dimensions = ?
+          THEN c.embedding
+          ELSE NULL
+        END AS embedding,
+        a.title,
+        a.source_label
+      FROM chunks c
+      INNER JOIN articles a ON a.id = c.article_id
+      ORDER BY a.imported_at ASC, c.ordinal ASC
+    `
+  ).all(
+    CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+    CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+    CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+    CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+  ).map(chunkRow);
+}
+function ftsExpression(query) {
+  const terms = query.normalize("NFKC").split(/[\s,，。！？!?；;：:、/\\|()[\]{}]+/u).map((term) => term.trim()).filter((term) => [...term].length >= 3).slice(0, 12);
+  if (terms.length === 0) {
+    return null;
+  }
+  return terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+}
+function lexicalRanking(database, query) {
+  const expression = ftsExpression(query);
+  if (expression === null) {
+    return [];
+  }
+  try {
+    return database.prepare(
+      `
+        SELECT chunk_id
+        FROM chunk_search
+        WHERE chunk_search MATCH ?
+        ORDER BY bm25(chunk_search, 0.0, 0.0, 4.0, 2.0, 1.0)
+        LIMIT ?
+      `
+    ).all(expression, SEARCH_CANDIDATE_LIMIT).map((value, rank) => ({
+      id: stringColumn(sqlRow(value), "chunk_id"),
+      rank
+    }));
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_QUERY_INVALID", "Knowledge query is invalid");
+  }
+}
+function dotProduct(left, right) {
+  let result = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    result += (left[index] ?? 0) * (right[index] ?? 0);
+  }
+  return result;
+}
+function semanticRanking(chunks, queryVector) {
+  const candidates = chunks.filter(
+    (chunk) => chunk.embedding !== null
+  ).map((chunk) => ({
+    id: chunk.id,
+    similarity: dotProduct(queryVector, chunk.embedding)
+  })).sort((left, right) => right.similarity - left.similarity || left.id.localeCompare(right.id)).slice(0, SEARCH_CANDIDATE_LIMIT);
+  const bestSimilarity = candidates[0]?.similarity;
+  if (bestSimilarity === void 0 || bestSimilarity < SEMANTIC_MINIMUM_SIMILARITY) {
+    return [];
+  }
+  return candidates.filter(
+    (candidate) => candidate.similarity >= SEMANTIC_MINIMUM_SIMILARITY && bestSimilarity - candidate.similarity <= SEMANTIC_MAXIMUM_DISTANCE_FROM_BEST
+  ).slice(0, SEARCH_CANDIDATE_LIMIT).map((candidate, rank) => ({
+    id: candidate.id,
+    rank
+  }));
+}
+function snippet(body) {
+  const characters = [...body];
+  return characters.length <= 360 ? body : `${characters.slice(0, 359).join("")}\u2026`;
+}
+function fusedResults(chunks, mode, lexical, semantic, limit) {
+  const scores = /* @__PURE__ */ new Map();
+  const addRanking = (ranking, lane, weight) => {
+    for (const candidate of ranking) {
+      const current = scores.get(candidate.id) ?? { lanes: /* @__PURE__ */ new Set(), score: 0 };
+      current.lanes.add(lane);
+      current.score += weight / (RRF_CONSTANT + candidate.rank + 1);
+      scores.set(candidate.id, current);
+    }
+  };
+  const semanticWeight = mode === "hybrid" ? 0.7 : mode === "semantic" ? 1 : 0;
+  const lexicalWeight = mode === "hybrid" ? 0.3 : mode === "lexical" ? 1 : 0;
+  addRanking(semantic, "semantic", semanticWeight);
+  addRanking(lexical, "lexical", lexicalWeight);
+  const byId = new Map(chunks.map((chunk) => [chunk.id, chunk]));
+  const articleCounts = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const [chunkId, score] of [...scores.entries()].sort(
+    (left, right) => right[1].score - left[1].score || left[0].localeCompare(right[0])
+  )) {
+    const chunk = byId.get(chunkId);
+    if (chunk === void 0 || (articleCounts.get(chunk.articleId) ?? 0) >= 2) {
+      continue;
+    }
+    articleCounts.set(chunk.articleId, (articleCounts.get(chunk.articleId) ?? 0) + 1);
+    results.push({
+      articleId: chunk.articleId,
+      chunkId: chunk.id,
+      chunkSha256: chunk.chunkSha256,
+      heading: chunk.heading,
+      lanes: [...score.lanes].sort(),
+      ordinal: chunk.ordinal,
+      rank: results.length + 1,
+      snippet: snippet(chunk.body),
+      sourceLabel: chunk.sourceLabel,
+      title: chunk.title
+    });
+    if (results.length >= limit) {
+      break;
+    }
+  }
+  return results;
+}
+var KnowledgeCli = class {
+  #currentDirectory;
+  #databasePath;
+  #embedder;
+  #isModelCached;
+  #now;
+  #randomUUID;
+  #writeStderr;
+  constructor(dependencies) {
+    const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+    const modelCacheDirectory = dependencies.modelCacheDirectory ?? path2.join(dependencies.homeDirectory, ".dxc", "models", "bge-small-zh-v1.5");
+    this.#currentDirectory = dependencies.currentDirectory;
+    this.#databasePath = dependencies.databasePath ?? path2.join(dependencies.homeDirectory, ".dxc", "content-memory.sqlite");
+    this.#embedder = dependencies.embedder ?? new LocalBgeKnowledgeEmbedder(modelCacheDirectory, now);
+    this.#isModelCached = dependencies.isModelCached ?? (() => isKnowledgeModelCached(modelCacheDirectory));
+    this.#now = now;
+    this.#randomUUID = dependencies.randomUUID ?? randomUUID;
+    this.#writeStderr = dependencies.writeStderr ?? (() => void 0);
+  }
+  async importArticles(options) {
+    if (options.files.length === 0) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_ARTICLE_INVALID",
+        "At least one article file is required"
+      );
+    }
+    if (!options.lexicalOnly) {
+      this.#writeStderr(
+        "Preparing the local semantic index; first use downloads a quantized model of about 24 MB.\n"
+      );
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const imported = [];
+      for (const file of options.files) {
+        const article = await prepareArticle(this.#currentDirectory, file);
+        const existing = findExistingArticle(database, article);
+        const unchanged = existing?.contentSha256 === article.contentSha256 && existing.chunkerVersion === CONTENT_KNOWLEDGE_CHUNKER_VERSION;
+        const semanticComplete = existing === void 0 ? false : semanticIndexComplete(database, existing.id);
+        if (unchanged && (options.lexicalOnly || semanticComplete)) {
+          imported.push({
+            article: articleSummary(existing),
+            semanticIndexed: semanticComplete,
+            status: "unchanged"
+          });
+          continue;
+        }
+        const vectors = options.lexicalOnly ? void 0 : await embedArticle(this.#embedder, article);
+        const saved = saveArticle(
+          database,
+          article,
+          existing,
+          vectors,
+          this.#now().toISOString(),
+          this.#randomUUID
+        );
+        imported.push({
+          article: articleSummary(saved),
+          semanticIndexed: vectors !== void 0,
+          status: existing === void 0 ? "created" : "updated"
+        });
+      }
+      return contentKnowledgeImportResultSchema.parse({
+        command: "knowledge.import",
+        data: {
+          imported,
+          model: options.lexicalOnly ? null : this.#embedder.model
+        },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async remove(articleId) {
+    if (!UUID_PATTERN.test(articleId)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_ARTICLE_INVALID",
+        "Knowledge article ID is invalid"
+      );
+    }
+    if (!await databaseExists(this.#databasePath)) {
+      return contentKnowledgeRemoveResultSchema.parse({
+        command: "knowledge.remove",
+        data: { articleId, removed: false },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        database.prepare("DELETE FROM chunk_search WHERE article_id = ?").run(articleId);
+        const result = database.prepare("DELETE FROM articles WHERE id = ?").run(articleId);
+        database.exec("COMMIT");
+        return contentKnowledgeRemoveResultSchema.parse({
+          command: "knowledge.remove",
+          data: {
+            articleId,
+            removed: result.changes > 0
+          },
+          ok: true
+        });
+      } catch {
+        database.exec("ROLLBACK");
+        throw new KnowledgeCliError(
+          "DXC_KNOWLEDGE_IO_FAILED",
+          "Unable to remove knowledge article"
+        );
+      }
+    } finally {
+      database.close();
+    }
+  }
+  async search(queryInput, modeInput, limitInput) {
+    const query = queryInput.trim();
+    const mode = contentKnowledgeSearchModeSchema.safeParse(modeInput);
+    if (query.length === 0 || query.length > 500 || !mode.success || !Number.isSafeInteger(limitInput) || limitInput < 1 || limitInput > MAXIMUM_RESULTS) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUERY_INVALID", "Knowledge query is invalid");
+    }
+    if (!await databaseExists(this.#databasePath)) {
+      return contentKnowledgeSearchResultSchema.parse({
+        command: "knowledge.search",
+        data: {
+          mode: mode.data,
+          model: mode.data === "lexical" ? null : this.#embedder.model,
+          query,
+          results: []
+        },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const chunks = loadChunks(database);
+      const usesSemantic = mode.data !== "lexical";
+      if (usesSemantic && chunks.some((chunk) => chunk.embedding === null)) {
+        throw new KnowledgeCliError(
+          "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
+          "All articles must have a semantic index before hybrid search"
+        );
+      }
+      const lexical = mode.data === "semantic" ? [] : lexicalRanking(database, query);
+      let semantic = [];
+      if (usesSemantic && chunks.length > 0) {
+        let queryVector;
+        try {
+          queryVector = await this.#embedder.embedQuery(query);
+        } catch {
+          throw new KnowledgeCliError(
+            "DXC_KNOWLEDGE_MODEL_FAILED",
+            "Local semantic model could not process the query"
+          );
+        }
+        semantic = semanticRanking(chunks, queryVector);
+      }
+      return contentKnowledgeSearchResultSchema.parse({
+        command: "knowledge.search",
+        data: {
+          mode: mode.data,
+          model: usesSemantic ? this.#embedder.model : null,
+          query,
+          results: fusedResults(chunks, mode.data, lexical, semantic, limitInput)
+        },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async status() {
+    let articleCount = 0;
+    let chunkCount = 0;
+    let semanticIndexedChunkCount = 0;
+    if (await databaseExists(this.#databasePath)) {
+      const database = await openDatabase(this.#databasePath);
+      try {
+        const articleRowValue = sqlRow(
+          database.prepare("SELECT COUNT(*) AS count FROM articles").get()
+        );
+        const chunkRowValue = sqlRow(
+          database.prepare(
+            `
+              SELECT
+                COUNT(*) AS count,
+                COALESCE(SUM(
+                  CASE
+                    WHEN embedding IS NOT NULL
+                      AND embedding_model = ?
+                      AND embedding_revision = ?
+                      AND embedding_quantization = ?
+                      AND embedding_dimensions = ?
+                    THEN 1
+                    ELSE 0
+                  END
+                ), 0) AS semantic_count
+              FROM chunks
+            `
+          ).get(
+            CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+            CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+            CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+            CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+          )
+        );
+        articleCount = numberColumn(articleRowValue, "count");
+        chunkCount = numberColumn(chunkRowValue, "count");
+        semanticIndexedChunkCount = numberColumn(chunkRowValue, "semantic_count");
+      } finally {
+        database.close();
+      }
+    }
+    return contentKnowledgeStatusResultSchema.parse({
+      command: "knowledge.status",
+      data: {
+        articleCount,
+        chunkCount,
+        databasePath: DATABASE_DISPLAY_PATH,
+        model: contentKnowledgeModelSchema.parse({
+          dimensions: CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
+          id: CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+          quantization: CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+          revision: CONTENT_KNOWLEDGE_EMBEDDING_REVISION
+        }),
+        modelCached: await this.#isModelCached(),
+        semanticIndexedChunkCount
+      },
+      ok: true
+    });
+  }
+};
+export {
+  KnowledgeCli,
+  KnowledgeCliError,
+  chunkHistoricalArticle
+};