@ontos-ai/knowhere-claw 0.2.0 → 0.2.2

package/dist/__tests__/channel-route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/ingest-tool.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/kg-service-test-helper.d.ts

@@ -0,0 +1,2 @@
+import type { KnowledgeGraphService } from "../kg-service";
+export declare function createKgServiceStub(): KnowledgeGraphService;

package/dist/__tests__/kg-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/read-result-file-tool.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tracker-progress.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_virtual/_rolldown/runtime.js

@@ -1,38 +1,4 @@
 //#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
-	if (typeof require !== "undefined") return require.apply(this, arguments);
-	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
-});
 //#endregion
-export { __commonJSMin, __esmMin, __exportAll, __require, __toESM };
+export { __esmMin };

package/dist/channel-delivery.d.ts

@@ -0,0 +1,21 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { ChannelRouteRecord } from "./types";
+type DeliverySurface = "discord" | "imessage" | "line" | "signal" | "slack" | "telegram" | "whatsapp";
+type DeliveryResult = {
+    delivered: boolean;
+    surface?: DeliverySurface;
+    to?: string;
+    accountId?: string;
+};
+export declare function deliverChannelMessage(params: {
+    api: OpenClawPluginApi;
+    operationLabel: string;
+    context?: unknown;
+    sessionKey?: string;
+    messages?: unknown[];
+    channelRoute?: ChannelRouteRecord;
+    text: string;
+    mediaUrl?: string;
+    mediaLocalRoots?: readonly string[];
+}): Promise<DeliveryResult>;
+export {};

package/dist/client.d.ts

@@ -0,0 +1,33 @@
+import type { KnowhereIngestRequest, KnowhereIngestResult, KnowhereJobList, KnowhereJobListRequest, KnowhereJobResult } from "./types";
+export declare class KnowhereClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly requestTimeoutMs;
+    private readonly uploadTimeoutMs;
+    private readonly pollIntervalMs;
+    private readonly pollTimeoutMs;
+    private readonly logger;
+    private readonly sdk;
+    constructor(params: {
+        apiKey: string;
+        baseUrl: string;
+        requestTimeoutMs: number;
+        uploadTimeoutMs: number;
+        pollIntervalMs: number;
+        pollTimeoutMs: number;
+        logger: {
+            debug?: (message: string) => void;
+            info: (message: string) => void;
+        };
+    });
+    ingestDocument(params: KnowhereIngestRequest): Promise<KnowhereIngestResult>;
+    private logPollProgress;
+    getJob(jobId: string): Promise<KnowhereJobResult>;
+    listJobs(options?: KnowhereJobListRequest): Promise<KnowhereJobList>;
+    getCompletedJobResult(jobId: string): Promise<KnowhereIngestResult>;
+    private downloadResultArchive;
+    private uploadFile;
+    private requestJson;
+    private requestBuffer;
+    private request;
+}

package/dist/client.js

@@ -1,9 +1,9 @@
 import { isRecord } from "./types.js";
-import { Knowhere } from "./node_modules/.pnpm/@knowhere-ai_sdk@0.1.1/node_modules/@knowhere-ai/sdk/dist/index.js";
 import { formatErrorMessage } from "./error-message.js";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { openAsBlob } from "node:fs";
+import { Knowhere } from "@knowhere-ai/sdk";
 //#region src/client.ts
 const RETRYABLE_STATUS_CODES = new Set([
 	409,

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { JsonSchemaObject, ResolvedKnowhereConfig, StringRecord, KnowledgeGraphConfig } from "./types";
+export declare const DEFAULT_BASE_URL = "https://api.knowhereto.ai";
+export declare const knowherePluginConfigSchema: JsonSchemaObject;
+export declare function resolveKnowhereConfig(api: OpenClawPluginApi): ResolvedKnowhereConfig;
+export declare const API_KEY_URL = "https://knowhereto.ai/api-keys";
+export declare const PURCHASE_CREDITS_URL = "https://knowhereto.ai/usage?buy=true";
+export declare function assertKnowhereApiKey(config: ResolvedKnowhereConfig): void;
+export declare function isPaymentRequiredError(error: unknown): boolean;
+export declare function formatPaymentRequiredMessage(): string;
+export declare function readPersistedApiKey(storageDir: string): Promise<string | null>;
+export declare function persistApiKey(storageDir: string, apiKey: string): Promise<void>;
+export declare function resolveKnowledgeGraphConfig(raw: StringRecord): KnowledgeGraphConfig;

package/dist/connect-builder.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Connection Builder Module
+ *
+ * TypeScript implementation of knowhere-api/apps/worker/app/services/connect_builder/builder.py
+ * Builds connections between chunks based on keyword overlap and content similarity.
+ */
+import type { PluginLogger } from "./types";
+/**
+ * Chunk data structure for building connections
+ */
+export interface ChunkData {
+    chunk_id: string;
+    path: string;
+    content: string;
+    metadata: {
+        keywords?: string[];
+        tokens?: string[];
+        summary?: string;
+        length?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Connection result between two chunks
+ */
+export interface Connection {
+    source: string;
+    target: string;
+    relation: string;
+    score: number;
+    sharedKeywords: string[];
+}
+/**
+ * Configuration for connection building
+ */
+export interface ConnectBuilderConfig {
+    minKeywordOverlap: number;
+    keywordScoreWeight: number;
+    maxConnectionsPerChunk: number;
+    minScoreThreshold: number;
+    crossFileOnly: boolean;
+    maxContentOverlap: number;
+}
+/**
+ * Main function to build connections between chunks
+ * Equivalent to Python: build_connections
+ */
+export declare function buildConnections(chunks: ChunkData[], config: ConnectBuilderConfig, logger?: PluginLogger): Connection[];

package/dist/connect-builder.js

@@ -120,7 +120,6 @@ function buildConnections(chunks, config, logger) {
 		const sourceChunk = chunkById.get(sourceId);
 		if (!sourceChunk) continue;
 		const sourceKeywords = getKeywords(sourceChunk);
-		sourceKeywords.map(normalizeKeyword);
 		const sourceFileKey = extractFileKey(sourceChunk.path);
 		for (const targetId of targetIds) {
 			const targetChunk = chunkById.get(targetId);
@@ -165,7 +164,7 @@ function buildConnections(chunks, config, logger) {
 			connectionsByChunk.get(conn.target).push(conn);
 		}
 		const kept = /* @__PURE__ */ new Set();
-		for (const [chunkId, conns] of connectionsByChunk) {
+		for (const [, conns] of connectionsByChunk) {
 			const topN = conns.sort((a, b) => b.score - a.score).slice(0, config.maxConnectionsPerChunk);
 			for (const conn of topN) kept.add(conn);
 		}

package/dist/error-message.d.ts

@@ -0,0 +1 @@
+export declare function formatErrorMessage(error: unknown): string;

package/dist/graph-builder.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Graph Builder Module
+ *
+ * TypeScript implementation of knowhere-api/apps/worker/app/services/connect_builder/graph_builder.py
+ * Builds file-level knowledge graphs from chunk connections with TF-IDF and importance scoring.
+ */
+import type { ChunkData, Connection } from "./connect-builder";
+import type { PluginLogger } from "./types";
+/**
+ * File-level edge in the knowledge graph
+ */
+interface FileEdge {
+    source: string;
+    target: string;
+    connection_count: number;
+    avg_score: number;
+    top_connections: Array<{
+        source_chunk: string;
+        source_id: string;
+        target_chunk: string;
+        target_id: string;
+        relation: string;
+        score: number;
+    }>;
+}
+/**
+ * File metadata in the knowledge graph
+ */
+interface FileMetadata {
+    chunks_count: number;
+    types: Record<string, number>;
+    top_keywords: string[];
+    top_summary: string;
+    importance: number;
+}
+/**
+ * Complete knowledge graph structure
+ */
+export interface KnowledgeGraph {
+    version: string;
+    stats: {
+        total_files: number;
+        total_chunks: number;
+        total_cross_file_edges: number;
+    };
+    files: Record<string, FileMetadata>;
+    edges: FileEdge[];
+}
+/**
+ * Chunk statistics for usage tracking
+ */
+export interface ChunkStats {
+    [chunkId: string]: {
+        hit_count: number;
+        last_accessed?: string;
+    };
+}
+/**
+ * Main function to build knowledge graph
+ * Equivalent to Python: build_knowledge_graph
+ */
+export declare function buildKnowledgeGraph(chunks: ChunkData[], connections: Connection[], chunkStats: ChunkStats, jiebaInitialized: boolean, logger?: PluginLogger): KnowledgeGraph;
+/**
+ * Incremental update: match new chunks against existing chunks
+ * Equivalent to Python: _incremental_connections
+ */
+export declare function incrementalConnections(newChunks: ChunkData[], existingChunks: ChunkData[], config: {
+    minKeywordOverlap: number;
+    keywordScoreWeight: number;
+    maxConnectionsPerChunk: number;
+    minScoreThreshold: number;
+    crossFileOnly: boolean;
+    maxContentOverlap: number;
+}, logger?: PluginLogger): Connection[];
+export {};

package/dist/graph-builder.js

@@ -1,7 +1,11 @@
-import { __toESM } from "./_virtual/_rolldown/runtime.js";
-import { require_nodejieba } from "./node_modules/.pnpm/nodejieba@2.6.0/node_modules/nodejieba/index.js";
+import * as nodejieba from "nodejieba";
 //#region src/graph-builder.ts
-var import_nodejieba = /* @__PURE__ */ __toESM(require_nodejieba(), 1);
+/**
+* Graph Builder Module
+*
+* TypeScript implementation of knowhere-api/apps/worker/app/services/connect_builder/graph_builder.py
+* Builds file-level knowledge graphs from chunk connections with TF-IDF and importance scoring.
+*/
 /**
 * Extract file key from chunk path
 */
@@ -25,13 +29,13 @@ function extractTokensFromContent(content, jiebaInitialized) {
 	const cleanContent = content.replace(/<[^>]*>/g, " ");
 	if (!jiebaInitialized) return cleanContent.split(/\s+/).filter((w) => w.length > 1);
 	try {
-		return import_nodejieba.cut(cleanContent).filter((token) => {
+		return nodejieba.cut(cleanContent).filter((token) => {
 			if (token.length <= 1) return false;
 			if (/^\d+$/.test(token)) return false;
 			if (/^[^\w\u4e00-\u9fa5]+$/.test(token)) return false;
 			return true;
 		});
-	} catch (error) {
+	} catch {
 		return cleanContent.split(/\s+/).filter((w) => w.length > 1);
 	}
 }

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("./types").JsonSchemaObject;
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;

package/dist/kg-service.d.ts

@@ -0,0 +1,38 @@
+import type { KnowledgeGraphConfig, PluginLogger, ToolRuntimeContext, KbMetadata, KnowledgeGraph, FileEdge } from "./types";
+export interface KnowledgeGraphServiceParams {
+    config: KnowledgeGraphConfig;
+    logger: PluginLogger;
+}
+type DegradationMode = "full" | "basic" | "disabled";
+export declare class KnowledgeGraphService {
+    private readonly config;
+    private readonly logger;
+    private degradationMode;
+    private buildQueues;
+    private jiebaInitialized;
+    constructor(params: KnowledgeGraphServiceParams);
+    initialize(): Promise<void>;
+    private checkPythonEnvironment;
+    private initializeJieba;
+    extractKeywords(text: string, topK?: number): Promise<string[]>;
+    resolveKbId(context: ToolRuntimeContext): string | null;
+    getKbPath(kbId: string): string;
+    ensureKbDirectory(kbId: string): Promise<string>;
+    saveDocumentToKb(params: {
+        kbId: string;
+        docId: string;
+        sourcePath: string;
+        keywords: string[];
+        metadata: Record<string, unknown>;
+    }): Promise<void>;
+    scheduleBuild(kbId: string, task: () => Promise<void>): Promise<void>;
+    buildKnowledgeGraph(kbId: string): Promise<void>;
+    private updateKbMetadata;
+    queryGraph(kbId: string, fileKey?: string): Promise<FileEdge[]>;
+    getKnowledgeGraph(kbId: string): Promise<KnowledgeGraph | null>;
+    listKnowledgeBases(): Promise<string[]>;
+    getKbMetadata(kbId: string): Promise<KbMetadata | null>;
+    isEnabled(): boolean;
+    getDegradationMode(): DegradationMode;
+}
+export {};

package/dist/kg-service.js

@@ -1,14 +1,11 @@
-import { __toESM } from "./_virtual/_rolldown/runtime.js";
-import { require_lib } from "./node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/index.js";
-import { require_nodejieba } from "./node_modules/.pnpm/nodejieba@2.6.0/node_modules/nodejieba/index.js";
 import { buildConnections, init_connect_builder } from "./connect-builder.js";
 import { buildKnowledgeGraph } from "./graph-builder.js";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import fs from "fs-extra";
 import os from "node:os";
+import * as nodejieba from "nodejieba";
 //#region src/kg-service.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-var import_nodejieba = /* @__PURE__ */ __toESM(require_nodejieba(), 1);
 init_connect_builder();
 const DEFAULT_CONNECT_CONFIG = {
 	minKeywordOverlap: 3,
@@ -25,6 +22,15 @@ const DEFAULT_KG_CONFIG = {
 	buildTimeout: 3e5,
 	notifyOnGraphFailure: false
 };
+function formatUnknownError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function extractKeywordText(item) {
+	if (typeof item === "string") return item;
+	if (typeof item === "number" || typeof item === "boolean" || typeof item === "bigint") return String(item);
+	if (typeof item === "object" && item !== null && "word" in item && typeof item.word === "string") return item.word;
+	return null;
+}
 var KnowledgeGraphService = class {
 	config;
 	logger;
@@ -68,7 +74,7 @@ var KnowledgeGraphService = class {
 	async checkPythonEnvironment() {
 		return new Promise((resolve, reject) => {
 			const python = spawn("python3", ["--version"]);
-			python.on("error", (err) => {
+			python.on("error", () => {
 				const error = /* @__PURE__ */ new Error("Python3 not found in PATH");
 				error.code = "PYTHON_MISSING";
 				reject(error);
@@ -87,10 +93,10 @@ var KnowledgeGraphService = class {
 	}
 	async initializeJieba() {
 		try {
-			import_nodejieba.load();
+			nodejieba.load();
 			this.jiebaInitialized = true;
 			this.logger.info("Nodejieba initialized successfully");
-		} catch (error) {
+		} catch {
 			const err = /* @__PURE__ */ new Error("Failed to initialize nodejieba");
 			err.code = "NODEJIEBA_MISSING";
 			throw err;
@@ -99,14 +105,14 @@ var KnowledgeGraphService = class {
 	async extractKeywords(text, topK = 20) {
 		if (this.degradationMode === "disabled") return [];
 		if (this.degradationMode === "full" && this.jiebaInitialized) try {
-			const rawKeywords = import_nodejieba.extract(text, topK);
-			return (Array.isArray(rawKeywords) ? rawKeywords : []).map((item) => typeof item === "string" ? item : String(item.word || item)).filter((kw) => {
+			const rawKeywords = nodejieba.extract(text, topK);
+			return (Array.isArray(rawKeywords) ? rawKeywords : []).map((item) => extractKeywordText(item)).filter((keyword) => keyword !== null).filter((kw) => {
 				if (kw.length <= 1) return false;
 				if (/^\d+$/.test(kw)) return false;
 				return true;
 			}).slice(0, topK);
 		} catch (error) {
-			this.logger.warn(`Jieba extraction failed, falling back to basic: ${error}`);
+			this.logger.warn(`Jieba extraction failed, falling back to basic: ${formatUnknownError(error)}`);
 			this.degradationMode = "basic";
 		}
 		return text.split(/\s+/).filter((w) => w.length > 1).slice(0, topK);
@@ -130,18 +136,18 @@ var KnowledgeGraphService = class {
 	}
 	async ensureKbDirectory(kbId) {
 		const kbPath = this.getKbPath(kbId);
-		await import_lib.default.ensureDir(kbPath);
+		await fs.ensureDir(kbPath);
 		return kbPath;
 	}
 	async saveDocumentToKb(params) {
 		const kbPath = await this.ensureKbDirectory(params.kbId);
 		const docDir = path.join(kbPath, params.docId);
-		await import_lib.default.ensureDir(docDir);
-		await import_lib.default.copy(params.sourcePath, docDir, { overwrite: true });
+		await fs.ensureDir(docDir);
+		await fs.copy(params.sourcePath, docDir, { overwrite: true });
 		const keywordsPath = path.join(docDir, "keywords.json");
-		await import_lib.default.writeJSON(keywordsPath, params.keywords, { spaces: 2 });
+		await fs.writeJSON(keywordsPath, params.keywords, { spaces: 2 });
 		const metadataPath = path.join(docDir, "metadata.json");
-		await import_lib.default.writeJSON(metadataPath, params.metadata, { spaces: 2 });
+		await fs.writeJSON(metadataPath, params.metadata, { spaces: 2 });
 		this.logger.info(`Document saved to knowledge base: kb=${params.kbId} doc=${params.docId}`);
 	}
 	async scheduleBuild(kbId, task) {
@@ -162,11 +168,11 @@ var KnowledgeGraphService = class {
 	}
 	async buildKnowledgeGraph(kbId) {
 		const kbPath = this.getKbPath(kbId);
-		const docs = await import_lib.default.readdir(kbPath);
+		const docs = await fs.readdir(kbPath);
 		const docDirs = [];
 		for (const doc of docs) {
 			const docPath = path.join(kbPath, doc);
-			if ((await import_lib.default.stat(docPath)).isDirectory() && doc !== "knowledge_graph.json" && doc !== "chunk_stats.json" && doc !== "kb_metadata.json") docDirs.push(doc);
+			if ((await fs.stat(docPath)).isDirectory() && doc !== "knowledge_graph.json" && doc !== "chunk_stats.json" && doc !== "kb_metadata.json") docDirs.push(doc);
 		}
 		if (docDirs.length < 2) {
 			this.logger.info(`Not enough documents for graph building (need >=2, have ${docDirs.length}), skipping`);
@@ -177,8 +183,8 @@ var KnowledgeGraphService = class {
 			const allChunks = [];
 			for (const docDir of docDirs) {
 				const chunksPath = path.join(kbPath, docDir, "chunks.json");
-				if (await import_lib.default.pathExists(chunksPath)) {
-					const chunksData = await import_lib.default.readJSON(chunksPath);
+				if (await fs.pathExists(chunksPath)) {
+					const chunksData = await fs.readJSON(chunksPath);
 					if (chunksData.chunks && Array.isArray(chunksData.chunks)) allChunks.push(...chunksData.chunks);
 				}
 			}
@@ -191,10 +197,10 @@ var KnowledgeGraphService = class {
 			this.logger.info(`Built ${connections.length} connections`);
 			const chunkStatsPath = path.join(kbPath, "chunk_stats.json");
 			let chunkStats = {};
-			if (await import_lib.default.pathExists(chunkStatsPath)) chunkStats = await import_lib.default.readJSON(chunkStatsPath);
+			if (await fs.pathExists(chunkStatsPath)) chunkStats = await fs.readJSON(chunkStatsPath);
 			const knowledgeGraph = buildKnowledgeGraph(allChunks, connections, chunkStats, this.jiebaInitialized, this.logger);
 			const graphFile = path.join(kbPath, "knowledge_graph.json");
-			await import_lib.default.writeJSON(graphFile, knowledgeGraph, { spaces: 2 });
+			await fs.writeJSON(graphFile, knowledgeGraph, { spaces: 2 });
 			this.logger.info(`Knowledge graph saved to ${graphFile}`);
 			await this.updateKbMetadata(kbPath, {
 				lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
@@ -202,41 +208,41 @@ var KnowledgeGraphService = class {
 			});
 			this.logger.info(`Knowledge graph built successfully for kb=${kbId}`);
 		} catch (error) {
-			this.logger.error(`Failed to build knowledge graph: ${error}`);
+			this.logger.error(`Failed to build knowledge graph: ${formatUnknownError(error)}`);
 			throw error;
 		}
 	}
 	async updateKbMetadata(kbPath, updates) {
 		const metadataPath = path.join(kbPath, "kb_metadata.json");
 		let metadata = {};
-		if (await import_lib.default.pathExists(metadataPath)) metadata = await import_lib.default.readJSON(metadataPath);
+		if (await fs.pathExists(metadataPath)) metadata = await fs.readJSON(metadataPath);
 		const updated = {
 			...metadata,
 			...updates
 		};
-		await import_lib.default.writeJSON(metadataPath, updated, { spaces: 2 });
+		await fs.writeJSON(metadataPath, updated, { spaces: 2 });
 	}
 	async queryGraph(kbId, fileKey) {
 		const graphPath = path.join(this.getKbPath(kbId), "knowledge_graph.json");
-		if (!await import_lib.default.pathExists(graphPath)) return [];
-		const graph = await import_lib.default.readJSON(graphPath);
+		if (!await fs.pathExists(graphPath)) return [];
+		const graph = await fs.readJSON(graphPath);
 		if (!fileKey) return graph.edges;
 		return graph.edges.filter((edge) => edge.source === fileKey || edge.target === fileKey);
 	}
 	async getKnowledgeGraph(kbId) {
 		const graphPath = path.join(this.getKbPath(kbId), "knowledge_graph.json");
-		if (!await import_lib.default.pathExists(graphPath)) return null;
-		return await import_lib.default.readJSON(graphPath);
+		if (!await fs.pathExists(graphPath)) return null;
+		return await fs.readJSON(graphPath);
 	}
 	async listKnowledgeBases() {
 		const knowhereRoot = path.join(os.homedir(), ".knowhere");
-		if (!await import_lib.default.pathExists(knowhereRoot)) return [];
-		return (await import_lib.default.readdir(knowhereRoot, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+		if (!await fs.pathExists(knowhereRoot)) return [];
+		return (await fs.readdir(knowhereRoot, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
 	}
 	async getKbMetadata(kbId) {
 		const metadataPath = path.join(this.getKbPath(kbId), "kb_metadata.json");
-		if (!await import_lib.default.pathExists(metadataPath)) return null;
-		return await import_lib.default.readJSON(metadataPath);
+		if (!await fs.pathExists(metadataPath)) return null;
+		return await fs.readJSON(metadataPath);
 	}
 	isEnabled() {
 		return this.degradationMode !== "disabled";

package/dist/parser.d.ts

@@ -0,0 +1,16 @@
+import type { KnowhereDownloadedResult, KnowhereManifest, KnowhereParseResult, KnowhereStatistics, StoredBrowseIndex, StoredChunk } from "./types";
+type KnowhereStoredResultSummary = {
+    manifest: KnowhereManifest;
+    chunkCount: number;
+    statistics: KnowhereStatistics;
+};
+export declare const STORED_BROWSE_INDEX_VERSION = 2;
+export declare function resolveResultEntryPath(rootDir: string, entryPath: string): string;
+export declare function buildStoredPathPrefixes(storedPath: string): string[];
+export declare function isStoredBrowseIndex(value: unknown): value is StoredBrowseIndex;
+export declare function buildStoredBrowseIndex(resultDir: string, manifest: KnowhereManifest, chunks: StoredChunk[]): Promise<StoredBrowseIndex>;
+export declare function extractKnowhereResultArchive(downloadedResult: KnowhereDownloadedResult, targetDir: string): Promise<void>;
+export declare function readStoredKnowhereResultSummary(resultDir: string): Promise<KnowhereStoredResultSummary>;
+export declare function readStoredKnowhereResultContent(resultDir: string): Promise<Omit<KnowhereParseResult, "browseIndex">>;
+export declare function readStoredKnowhereParseResult(resultDir: string): Promise<KnowhereParseResult>;
+export {};

package/dist/parser.js

@@ -1,8 +1,8 @@
 import { isNodeError, isRecord } from "./types.js";
-import { strFromU8, unzipSync } from "./node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { strFromU8, unzipSync } from "fflate";
 const CHUNKS_FILE_NAME = "chunks.json";
 const FULL_MARKDOWN_FILE_NAME = "full.md";
 const HIERARCHY_FILE_NAME = "hierarchy.json";

package/dist/session.d.ts

@@ -0,0 +1,11 @@
+export type ParsedConversationSessionKey = {
+    agentId: string;
+    surface: string;
+    remainder: string;
+    segments: string[];
+};
+export declare function parseConversationSessionKey(sessionKey: string | undefined): ParsedConversationSessionKey | undefined;
+export declare function normalizeConversationScopeKey(sessionKey: string | undefined): string | undefined;
+export declare function resolveSharedConversationScopeKey(sessionKey: string | undefined): string | undefined;
+export declare function findConversationSegmentValue(session: ParsedConversationSessionKey | undefined, ...keys: string[]): string | undefined;
+export declare function deriveMessageContextScopeKey(context: unknown): string | undefined;