@ontos-ai/knowhere-claw 0.1.0-beta.0

package/dist/store.js

@@ -0,0 +1,482 @@
+import { isNodeError } from "./types.js";
+import { hashString, normalizeWhitespace, sanitizeStringArray, slugify } from "./text.js";
+import { deriveMessageContextScopeKey } from "./session.js";
+import { buildStoredBrowseIndex, extractKnowhereResultArchive, isStoredBrowseIndex, readStoredKnowhereResultContent, readStoredKnowhereResultSummary, resolveResultEntryPath } from "./parser.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#region src/store.ts
+const INDEX_VERSION = 1;
+const BROWSE_INDEX_FILE_NAME = "browse-index.json";
+const DOCUMENT_PAYLOAD_CACHE_LIMIT = 16;
+const METADATA_FILE_NAME = "metadata.json";
+const RESULT_DIRECTORY_NAME = "result";
+async function pathExists(targetPath) {
+	try {
+		await fs.access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensureDir(targetPath) {
+	await fs.mkdir(targetPath, { recursive: true });
+}
+async function readJson(targetPath, fallback) {
+	try {
+		const raw = await fs.readFile(targetPath, "utf-8");
+		return JSON.parse(raw);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return fallback;
+		throw error;
+	}
+}
+async function writeJsonAtomic(targetPath, value) {
+	await ensureDir(path.dirname(targetPath));
+	const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+	await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+	await fs.rename(tempPath, targetPath);
+}
+function deriveDocumentTitle(payload, manifest) {
+	const candidates = [
+		payload.title,
+		manifest.source_file_name,
+		payload.jobResult.file_name,
+		payload.fileName,
+		payload.source
+	];
+	for (const candidate of candidates) if (typeof candidate === "string" && normalizeWhitespace(candidate)) {
+		const value = normalizeWhitespace(candidate);
+		try {
+			if (/^https?:\/\//i.test(value)) {
+				const url = new URL(value);
+				const fileName = path.posix.basename(url.pathname);
+				if (fileName) return fileName;
+			}
+		} catch {
+			return value;
+		}
+		return path.basename(value);
+	}
+	return "Document";
+}
+function extractFileNameFromSource(source) {
+	const value = normalizeWhitespace(source);
+	if (!value) return null;
+	try {
+		if (/^https?:\/\//i.test(value)) {
+			const url = new URL(value);
+			const fileName = path.posix.basename(url.pathname);
+			if (fileName && fileName !== "/" && fileName !== ".") return fileName;
+			return null;
+		}
+	} catch {
+		return path.basename(value);
+	}
+	const fileName = path.basename(value);
+	return fileName && fileName !== "." ? fileName : null;
+}
+function deriveOriginalFileName(payload, manifest) {
+	const candidates = [
+		payload.fileName,
+		manifest.source_file_name,
+		payload.jobResult.file_name,
+		extractFileNameFromSource(payload.source)
+	];
+	for (const candidate of candidates) if (typeof candidate === "string" && normalizeWhitespace(candidate)) return normalizeWhitespace(candidate);
+	return null;
+}
+function buildDocumentId(payload, manifest) {
+	if (payload.docId) return slugify(payload.docId, "document");
+	const seed = [
+		payload.sourceType,
+		payload.source,
+		payload.fileName,
+		payload.title,
+		manifest.data_id
+	].filter(Boolean).join("|");
+	return `${slugify(deriveDocumentTitle(payload, manifest), "document")}-${hashString(seed || String(Date.now())).slice(0, 8)}`;
+}
+function buildUniqueDocumentId(docId, seed, existingIds) {
+	let nextDocId = docId;
+	let counter = 1;
+	while (existingIds.has(nextDocId)) {
+		nextDocId = `${docId}-${hashString(`${seed}-${counter}`).slice(0, 6)}`;
+		counter += 1;
+	}
+	return nextDocId;
+}
+function createEmptyIndex(scope) {
+	return {
+		version: INDEX_VERSION,
+		scopeMode: scope.mode,
+		scopeKey: scope.key,
+		updatedAt: null,
+		documents: []
+	};
+}
+function buildStoredDocumentPaths(scope, docId) {
+	const documentDir = path.join(scope.documentsDir, docId);
+	return {
+		browseIndexPath: path.join(documentDir, BROWSE_INDEX_FILE_NAME),
+		documentDir,
+		metadataPath: path.join(documentDir, METADATA_FILE_NAME),
+		resultDir: path.join(documentDir, RESULT_DIRECTORY_NAME)
+	};
+}
+async function readStoredDocumentMetadata(metadataPath) {
+	try {
+		const rawDocument = await fs.readFile(metadataPath, "utf-8");
+		return JSON.parse(rawDocument);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function isCurrentIndex(index, scope) {
+	return index.version === INDEX_VERSION && index.scopeMode === scope.mode && index.scopeKey === scope.key;
+}
+var KnowhereStore = class {
+	rootDir;
+	scopeMode;
+	logger;
+	indexCache;
+	documentPayloadCache;
+	scopeAccessChains;
+	scopeKeyAliases;
+	sessionScopeKeysBySessionId;
+	sessionScopeKeysBySessionKey;
+	constructor(params) {
+		this.rootDir = params.rootDir;
+		this.scopeMode = params.scopeMode;
+		this.logger = params.logger;
+		this.indexCache = /* @__PURE__ */ new Map();
+		this.documentPayloadCache = /* @__PURE__ */ new Map();
+		this.scopeAccessChains = /* @__PURE__ */ new Map();
+		this.scopeKeyAliases = /* @__PURE__ */ new Map();
+		this.sessionScopeKeysBySessionId = /* @__PURE__ */ new Map();
+		this.sessionScopeKeysBySessionKey = /* @__PURE__ */ new Map();
+	}
+	registerScopeAlias(context) {
+		const canonicalScopeKey = this.resolveCanonicalScopeKey(context.scopeKey);
+		const sessionKey = normalizeWhitespace(context.sessionKey);
+		const sessionId = normalizeWhitespace(context.sessionId);
+		if (sessionKey) this.sessionScopeKeysBySessionKey.set(sessionKey, canonicalScopeKey);
+		if (sessionId) this.sessionScopeKeysBySessionId.set(sessionId, canonicalScopeKey);
+		return canonicalScopeKey;
+	}
+	registerMessageScope(context) {
+		const sessionKey = normalizeWhitespace(context.sessionKey);
+		const sessionId = normalizeWhitespace(context.sessionId);
+		if (sessionKey || sessionId) return this.registerScopeAlias({
+			scopeKey: sessionKey || sessionId || "global",
+			sessionKey,
+			sessionId
+		});
+		const messageScopeKey = deriveMessageContextScopeKey(context.messageContext);
+		if (!messageScopeKey) return;
+		return this.registerScopeAlias({
+			scopeKey: messageScopeKey,
+			sessionKey,
+			sessionId
+		});
+	}
+	inheritScopeAlias(context) {
+		const requesterScopeKey = this.resolveKnownScopeKey({
+			sessionId: context.requesterSessionId,
+			sessionKey: context.requesterSessionKey
+		});
+		if (!requesterScopeKey) return;
+		return this.registerScopeAlias({
+			scopeKey: requesterScopeKey,
+			sessionKey: context.childSessionKey,
+			sessionId: context.childSessionId
+		});
+	}
+	resolveScope(context = {}) {
+		const agentId = normalizeWhitespace(context.agentId);
+		const sessionKey = normalizeWhitespace(context.sessionKey);
+		const sessionId = normalizeWhitespace(context.sessionId);
+		let rawKey = "global";
+		const resolvedScopeKey = this.resolveKnownScopeKey(context);
+		if (this.scopeMode === "session") rawKey = resolvedScopeKey || sessionKey || sessionId || agentId || "global";
+		else if (this.scopeMode === "agent") rawKey = agentId || resolvedScopeKey || sessionKey || sessionId || "global";
+		const mode = rawKey === "global" ? "global" : this.scopeMode;
+		const hash = hashString(rawKey).slice(0, 10);
+		const dirName = rawKey === "global" ? "global" : `${mode}-${slugify(rawKey, "scope").slice(0, 40)}-${hash}`;
+		const scopeRoot = path.join(this.rootDir, dirName);
+		return {
+			mode,
+			key: rawKey,
+			label: rawKey === "global" ? "global" : `${mode}:${rawKey}`,
+			rootDir: scopeRoot,
+			documentsDir: path.join(scopeRoot, "documents"),
+			indexPath: path.join(scopeRoot, "index.json")
+		};
+	}
+	async listDocuments(scope) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			return [...(await this.getIndex(scope, true)).documents].sort((left, right) => String(right.updatedAt || right.ingestedAt || "").localeCompare(String(left.updatedAt || left.ingestedAt || "")));
+		});
+	}
+	async loadDocumentPayload(scope, docId) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			const cacheKey = this.buildDocumentPayloadCacheKey(scope, docId);
+			const cachedPayload = this.documentPayloadCache.get(cacheKey);
+			if (cachedPayload) {
+				this.touchDocumentPayloadCache(cacheKey, cachedPayload);
+				return cachedPayload;
+			}
+			const paths = buildStoredDocumentPaths(scope, docId);
+			const metadata = await readStoredDocumentMetadata(paths.metadataPath);
+			if (!metadata) return null;
+			const resultContent = await readStoredKnowhereResultContent(paths.resultDir);
+			const browseIndex = await this.loadOrBuildBrowseIndex(paths, resultContent.manifest, resultContent.chunks);
+			const payload = {
+				version: metadata.version,
+				document: metadata.document,
+				manifest: resultContent.manifest,
+				jobResult: metadata.jobResult,
+				fullMarkdown: resultContent.fullMarkdown,
+				hierarchy: resultContent.hierarchy,
+				browseIndex,
+				rawZipSha1: metadata.rawZipSha1,
+				chunks: resultContent.chunks
+			};
+			this.touchDocumentPayloadCache(cacheKey, payload);
+			return payload;
+		});
+	}
+	async readResultFile(scope, docId, relativePath) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			const paths = buildStoredDocumentPaths(scope, docId);
+			const metadata = await readStoredDocumentMetadata(paths.metadataPath);
+			if (!metadata) return null;
+			const filePath = resolveResultEntryPath(paths.resultDir, relativePath);
+			try {
+				const text = await fs.readFile(filePath, "utf-8");
+				return {
+					document: metadata.document,
+					relativePath: path.posix.normalize(relativePath.replace(/\\/g, "/")),
+					text
+				};
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") return {
+					document: metadata.document,
+					relativePath: path.posix.normalize(relativePath.replace(/\\/g, "/")),
+					text: null
+				};
+				throw error;
+			}
+		});
+	}
+	async saveDownloadedDocument(scope, payload, options = {}) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			const index = await this.getIndex(scope, true);
+			const existingIds = new Set(index.documents.map((document) => document.id));
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const tempPaths = buildStoredDocumentPaths(scope, `.tmp-${randomUUID()}`);
+			try {
+				await extractKnowhereResultArchive(payload.downloadedResult, tempPaths.resultDir);
+				const resultSummary = await readStoredKnowhereResultSummary(tempPaths.resultDir);
+				const resultContent = await readStoredKnowhereResultContent(tempPaths.resultDir);
+				const browseIndex = await buildStoredBrowseIndex(tempPaths.resultDir, resultContent.manifest, resultContent.chunks);
+				const documentIdSeed = [
+					payload.sourceType,
+					payload.source,
+					payload.fileName,
+					payload.title,
+					resultSummary.manifest.data_id,
+					String(now)
+				].filter(Boolean).join("|");
+				const documentIdCandidate = buildDocumentId(payload, resultSummary.manifest);
+				const existingDocument = index.documents.find((document) => document.id === documentIdCandidate);
+				if (payload.docId && existingDocument && options.overwrite !== true) throw new Error(`Document ${documentIdCandidate} already exists in scope ${scope.label}.`);
+				const docId = existingDocument && options.overwrite === true ? existingDocument.id : buildUniqueDocumentId(documentIdCandidate, documentIdSeed, existingIds);
+				const paths = buildStoredDocumentPaths(scope, docId);
+				const originalFileName = deriveOriginalFileName(payload, resultSummary.manifest);
+				const documentRecord = {
+					id: docId,
+					title: deriveDocumentTitle(payload, resultSummary.manifest),
+					sourceType: payload.sourceType,
+					source: payload.source,
+					sourceLabel: payload.sourceLabel || (payload.sourceType === "url" ? payload.source : originalFileName || payload.source),
+					fileName: payload.fileName,
+					originalFileName,
+					dataId: payload.dataId || resultSummary.manifest.data_id || null,
+					jobId: payload.jobResult.job_id || payload.job.job_id,
+					checksum: resultSummary.manifest.checksum?.value || null,
+					resultUrl: payload.jobResult.result_url || null,
+					resultUrlExpiresAt: payload.jobResult.result_url_expires_at || null,
+					scopeLabel: scope.label,
+					tags: sanitizeStringArray(payload.tags),
+					ingestedAt: existingDocument?.ingestedAt || now,
+					updatedAt: now,
+					chunkCount: resultSummary.chunkCount,
+					statistics: resultSummary.statistics
+				};
+				const metadata = {
+					version: INDEX_VERSION,
+					document: documentRecord,
+					jobResult: payload.jobResult,
+					rawZipSha1: payload.downloadedResult.rawZipSha1
+				};
+				await writeJsonAtomic(tempPaths.metadataPath, metadata);
+				await writeJsonAtomic(tempPaths.browseIndexPath, browseIndex);
+				await this.removeDocumentArtifacts(paths);
+				await ensureDir(scope.documentsDir);
+				await fs.rename(tempPaths.documentDir, paths.documentDir);
+				index.documents = index.documents.filter((document) => document.id !== docId).concat(documentRecord);
+				this.deleteDocumentPayloadCache(scope, docId);
+				await this.persistIndex(scope, index);
+				return documentRecord;
+			} catch (error) {
+				await this.removeDocumentArtifacts(tempPaths).catch(() => void 0);
+				throw error;
+			}
+		});
+	}
+	async removeDocument(scope, docId) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			const index = await this.getIndex(scope, true);
+			const existingDocument = index.documents.find((document) => document.id === docId);
+			if (!existingDocument) return null;
+			await this.removeDocumentArtifacts(buildStoredDocumentPaths(scope, docId));
+			index.documents = index.documents.filter((document) => document.id !== docId);
+			this.deleteDocumentPayloadCache(scope, docId);
+			await this.persistIndex(scope, index);
+			return existingDocument;
+		});
+	}
+	async clearScope(scope) {
+		return this.runWithScopeAccessLock(scope, async () => {
+			const removedDocuments = [...(await this.getIndex(scope, true)).documents];
+			if (await pathExists(scope.rootDir)) await fs.rm(scope.rootDir, {
+				recursive: true,
+				force: true
+			});
+			this.indexCache.delete(scope.rootDir);
+			this.deleteScopeDocumentPayloadCaches(scope);
+			this.logger.info(`knowhere: cleared scope ${scope.label} (${removedDocuments.length} document${removedDocuments.length === 1 ? "" : "s"})`);
+			return removedDocuments;
+		});
+	}
+	async getIndex(scope, isScopeLocked = false) {
+		const cacheKey = scope.rootDir;
+		const cached = this.indexCache.get(cacheKey);
+		if (cached) return cached;
+		const index = await readJson(scope.indexPath, createEmptyIndex(scope));
+		if (!isCurrentIndex(index, scope)) {
+			if (!isScopeLocked) return this.runWithScopeAccessLock(scope, async () => this.getIndex(scope, true));
+			const rebuiltIndex = await this.rebuildIndex(scope);
+			this.indexCache.set(cacheKey, rebuiltIndex);
+			return rebuiltIndex;
+		}
+		this.indexCache.set(cacheKey, index);
+		return index;
+	}
+	async persistIndex(scope, index) {
+		index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeJsonAtomic(scope.indexPath, index);
+		this.indexCache.set(scope.rootDir, index);
+		this.logger.debug?.(`knowhere: persisted index for scope ${scope.label}`);
+	}
+	async runWithScopeAccessLock(scope, operation) {
+		const accessKey = scope.rootDir;
+		const previous = this.scopeAccessChains.get(accessKey) ?? Promise.resolve();
+		let releaseCurrent;
+		const current = new Promise((resolve) => {
+			releaseCurrent = resolve;
+		});
+		const queued = previous.catch(() => void 0).then(() => current);
+		this.scopeAccessChains.set(accessKey, queued);
+		await previous.catch(() => void 0);
+		try {
+			return await operation();
+		} finally {
+			releaseCurrent?.();
+			if (this.scopeAccessChains.get(accessKey) === queued) this.scopeAccessChains.delete(accessKey);
+		}
+	}
+	async removeDocumentArtifacts(paths) {
+		if (await pathExists(paths.documentDir)) await fs.rm(paths.documentDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	buildDocumentPayloadCacheKey(scope, docId) {
+		return `${scope.rootDir}:${docId}`;
+	}
+	touchDocumentPayloadCache(cacheKey, payload) {
+		this.documentPayloadCache.delete(cacheKey);
+		this.documentPayloadCache.set(cacheKey, payload);
+		while (this.documentPayloadCache.size > DOCUMENT_PAYLOAD_CACHE_LIMIT) {
+			const oldestKey = this.documentPayloadCache.keys().next().value;
+			if (!oldestKey) break;
+			this.documentPayloadCache.delete(oldestKey);
+		}
+	}
+	deleteDocumentPayloadCache(scope, docId) {
+		this.documentPayloadCache.delete(this.buildDocumentPayloadCacheKey(scope, docId));
+	}
+	deleteScopeDocumentPayloadCaches(scope) {
+		const cacheKeyPrefix = `${scope.rootDir}:`;
+		for (const cacheKey of this.documentPayloadCache.keys()) if (cacheKey.startsWith(cacheKeyPrefix)) this.documentPayloadCache.delete(cacheKey);
+	}
+	async loadOrBuildBrowseIndex(paths, manifest, chunks) {
+		if (await pathExists(paths.browseIndexPath)) {
+			try {
+				const existingBrowseIndex = await readJson(paths.browseIndexPath, null);
+				if (isStoredBrowseIndex(existingBrowseIndex)) return existingBrowseIndex;
+			} catch (error) {
+				this.logger.warn(`knowhere: failed to read browse index ${paths.browseIndexPath}; rebuilding. ${error instanceof Error ? error.message : String(error)}`);
+			}
+			this.logger.info(`knowhere: rebuilding browse index for ${paths.documentDir} (expected version 2)`);
+		}
+		const browseIndex = await buildStoredBrowseIndex(paths.resultDir, manifest, chunks);
+		await writeJsonAtomic(paths.browseIndexPath, browseIndex);
+		return browseIndex;
+	}
+	resolveCanonicalScopeKey(scopeKey) {
+		let currentKey = normalizeWhitespace(scopeKey) || scopeKey;
+		const seen = /* @__PURE__ */ new Set();
+		while (!seen.has(currentKey)) {
+			seen.add(currentKey);
+			const alias = this.scopeKeyAliases.get(currentKey);
+			if (!alias) break;
+			currentKey = alias;
+		}
+		return currentKey;
+	}
+	resolveKnownScopeKey(context) {
+		const sessionId = normalizeWhitespace(context.sessionId);
+		if (sessionId) {
+			const scopeKey = this.sessionScopeKeysBySessionId.get(sessionId);
+			if (scopeKey) return this.resolveCanonicalScopeKey(scopeKey);
+		}
+		const sessionKey = normalizeWhitespace(context.sessionKey);
+		if (sessionKey) {
+			const scopeKey = this.sessionScopeKeysBySessionKey.get(sessionKey);
+			if (scopeKey) return this.resolveCanonicalScopeKey(scopeKey);
+		}
+	}
+	async rebuildIndex(scope) {
+		const rebuiltIndex = createEmptyIndex(scope);
+		if (!await pathExists(scope.documentsDir)) {
+			await this.persistIndex(scope, rebuiltIndex);
+			return rebuiltIndex;
+		}
+		const documentEntries = await fs.readdir(scope.documentsDir, { withFileTypes: true });
+		for (const documentEntry of documentEntries) {
+			if (!documentEntry.isDirectory()) continue;
+			const documentPath = path.join(scope.documentsDir, documentEntry.name);
+			const metadata = await readStoredDocumentMetadata(path.join(documentPath, METADATA_FILE_NAME));
+			if (!metadata?.document) continue;
+			rebuiltIndex.documents.push(metadata.document);
+		}
+		await this.persistIndex(scope, rebuiltIndex);
+		return rebuiltIndex;
+	}
+};
+//#endregion
+export { KnowhereStore };

package/dist/text.d.ts

@@ -0,0 +1,10 @@
+export declare function normalizeWhitespace(value: unknown): string;
+export declare function truncateText(value: unknown, maxChars: number): string;
+export declare function slugify(value: unknown, fallback?: string): string;
+export declare function hashString(value: string): string;
+export declare function sanitizeStringArray(value: unknown): string[];
+export declare function toComparableText(value: unknown): string;
+export declare function stripHtmlTags(text: string): string;
+export declare function stripLatex(text: string): string;
+export declare function normalizeUnicode(text: string): string;
+export declare function normalizeForGrep(text: string): string;

package/dist/text.js

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+//#region src/text.ts
+function normalizeWhitespace(value) {
+	if (typeof value !== "string") return "";
+	return value.replace(/\s+/g, " ").trim();
+}
+function slugify(value, fallback = "item") {
+	return normalizeWhitespace(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || fallback;
+}
+function hashString(value) {
+	return createHash("sha1").update(value).digest("hex");
+}
+function sanitizeStringArray(value) {
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string").map((entry) => normalizeWhitespace(entry)).filter(Boolean);
+	if (typeof value === "string") {
+		const normalized = normalizeWhitespace(value);
+		return normalized ? [normalized] : [];
+	}
+	return [];
+}
+function stripHtmlTags(text) {
+	return text.replace(/<[^>]*>/g, "");
+}
+function stripLatex(text) {
+	return text.replace(/\$([^$]*)\$/g, "$1").replace(/\\text\{([^}]*)}/g, "$1").replace(/\\(?:text(?:bf|it|tt|sf|sc|rm)|math(?:rm|bf|it|sf|tt|cal|bb|frak))\{([^}]*)}/g, "$1").replace(/\\(?:emph|underline|overline)\{([^}]*)}/g, "$1").replace(/\\([%$&#_])/g, "$1").replace(/\\(?:right|Right)arrow/g, "→").replace(/\\(?:left|Left)arrow/g, "←").replace(/\\leftrightarrow/g, "↔").replace(/\\times/g, "×").replace(/\\cdot/g, "·").replace(/\\pm/g, "±").replace(/\\leq/g, "≤").replace(/\\geq/g, "≥").replace(/\\neq/g, "≠").replace(/\\approx/g, "≈").replace(/\\(sup|inf|max|min|log|ln|sin|cos|tan|exp|lim)\b/g, "$1").replace(/\\([{}])/g, "$1").replace(/\\\\/g, " ").replace(/\\[a-zA-Z]+/g, "");
+}
+function normalizeUnicode(text) {
+	return text.replace(/[\u2018\u2019\u201A]/g, "'").replace(/[\u201C\u201D\u201E]/g, "\"").replace(/[\u2013\u2014]/g, "-").replace(/[\u00A0\u2009\u200A\u200B\u2007\u202F]/g, " ").replace(/\u2026/g, "...").replace(/\u2022/g, "-");
+}
+function normalizeForGrep(text) {
+	return stripHtmlTags(stripLatex(normalizeUnicode(text))).replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { hashString, normalizeForGrep, normalizeWhitespace, sanitizeStringArray, slugify };

package/dist/tools.d.ts

@@ -0,0 +1,9 @@
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { KnowhereStore } from "./store";
+import type { KnowhereAutoGroundingController, ResolvedKnowhereConfig, ToolRuntimeContext } from "./types";
+export declare function createKnowhereToolFactory(params: {
+    api: OpenClawPluginApi;
+    config: ResolvedKnowhereConfig;
+    store: KnowhereStore;
+    autoGroundingController?: KnowhereAutoGroundingController;
+}): (ctx: ToolRuntimeContext) => AnyAgentTool[];