@ontos-ai/knowhere-claw 0.2.3 → 0.2.5

package/README.md

@@ -1,7 +1,7 @@
 # Knowhere for OpenClaw
 
 Knowhere is an OpenClaw plugin that parses documents and URLs with Knowhere,
-stores the extracted result package in OpenClaw state, and gives agents a
+stores extracted Knowhere files in OpenClaw state, and gives agents a
 browse-first toolset for grounded document work.
 
 Quick mental model:
@@ -22,7 +22,7 @@ the machine running that Gateway, then restart that Gateway.
 ## What You Get
 
 - Ingest local files or document URLs with Knowhere
-- Store parsed result packages inside OpenClaw-managed state
+- Store parsed documents inside OpenClaw-managed state
 - Preview document structure, search chunks, and inspect raw result files
 - Reuse stored documents across `session`, `agent`, or `global` scope
 - Ship bundled `knowhere` and `knowhere_memory` skills so agents prefer this
@@ -73,7 +73,7 @@ Config notes:
 - `pollIntervalMs`, `pollTimeoutMs`, `requestTimeoutMs`, `uploadTimeoutMs`:
   optional tuning for job polling, API calls, and large uploads.
 - An explicit `storageDir` such as
-  `/home/<user>/.openclaw/plugin-state/knowhere` makes stored result packages
+  `/home/<user>/.openclaw/plugin-state/knowhere` makes stored documents
   easier to inspect, back up, or clean up.
 
 ## How OpenClaw Uses It
@@ -110,8 +110,8 @@ actually call the plugin tools.
 Within each scope, the plugin keeps:
 
 - an `index.json` cache of stored document summaries
-- per-document metadata and browse indexes
-- the extracted Knowhere result package under `result/`
+- a `metadata/` directory with one JSON record per stored document
+- the extracted Knowhere result files directly inside each document directory
 
 ## Common Workflow
 

package/dist/client.js

@@ -1,8 +1,8 @@
 import { isRecord } from "./types.js";
 import { formatErrorMessage } from "./error-message.js";
+import { openAsBlob } from "node:fs";
 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([

package/dist/config.d.ts

@@ -2,6 +2,14 @@ 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;
+/**
+ * Return the effective plugin config object, merging the persisted
+ * resolved-config when the live pluginConfig is missing explicit fields
+ * (i.e. in agent subprocesses).  Both `resolveKnowhereConfig` and
+ * `resolveKnowledgeGraphConfig` should read from this merged result so
+ * that subprocess instances inherit the gateway's full configuration.
+ */
+export declare function resolveEffectivePluginConfig(api: OpenClawPluginApi): StringRecord;
 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";

package/dist/config.js

@@ -1,4 +1,5 @@
 import { isRecord } from "./types.js";
+import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 //#region src/config.ts
@@ -147,36 +148,83 @@ function readScopeMode(raw) {
 	if (value === "session" || value === "agent" || value === "global") return value;
 	return KNOWHERE_PLUGIN_DEFAULTS.scopeMode;
 }
+const RESOLVED_CONFIG_STATE_FILE = "resolved-config.json";
+function readPersistedResolvedConfigSync(stateDir) {
+	const filePath = path.join(stateDir, RESOLVED_CONFIG_STATE_FILE);
+	try {
+		const raw = readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (isRecord(parsed)) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function persistResolvedConfig(stateDir, config) {
+	await fs.mkdir(stateDir, { recursive: true });
+	const filePath = path.join(stateDir, RESOLVED_CONFIG_STATE_FILE);
+	await fs.writeFile(filePath, JSON.stringify(config, null, 2), "utf-8");
+}
+function hasExplicitPluginConfig(raw) {
+	return Boolean(readString(raw, "scopeMode") || readString(raw, "storageDir"));
+}
+/**
+* Return the effective plugin config object, merging the persisted
+* resolved-config when the live pluginConfig is missing explicit fields
+* (i.e. in agent subprocesses).  Both `resolveKnowhereConfig` and
+* `resolveKnowledgeGraphConfig` should read from this merged result so
+* that subprocess instances inherit the gateway's full configuration.
+*/
+function resolveEffectivePluginConfig(api) {
+	const raw = isRecord(api.pluginConfig) ? api.pluginConfig : {};
+	const stateDir = api.runtime.state.resolveStateDir();
+	if (!hasExplicitPluginConfig(raw)) {
+		const persisted = readPersistedResolvedConfigSync(stateDir);
+		if (persisted) return {
+			...persisted,
+			...raw
+		};
+	}
+	return raw;
+}
 function resolveKnowhereConfig(api) {
 	const raw = isRecord(api.pluginConfig) ? api.pluginConfig : {};
 	const stateDir = api.runtime.state.resolveStateDir();
-	const storageDirRaw = readString(raw, "storageDir");
-	return {
+	const hasExplicit = hasExplicitPluginConfig(raw);
+	const effective = resolveEffectivePluginConfig(api);
+	const storageDirRaw = readString(effective, "storageDir");
+	const config = {
 		apiKey: readString(raw, "apiKey") || process.env.KNOWHERE_API_KEY || "",
 		baseUrl: readString(raw, "baseUrl") || process.env.KNOWHERE_BASE_URL || "https://api.knowhereto.ai",
 		storageDir: storageDirRaw ? api.resolvePath(storageDirRaw) : path.join(stateDir, "plugins", api.id),
-		scopeMode: readScopeMode(raw),
-		pollIntervalMs: readNumber(raw, "pollIntervalMs", KNOWHERE_PLUGIN_DEFAULTS.pollIntervalMs, {
+		scopeMode: readScopeMode(effective),
+		pollIntervalMs: readNumber(effective, "pollIntervalMs", KNOWHERE_PLUGIN_DEFAULTS.pollIntervalMs, {
 			min: 1e3,
 			max: 6e4,
 			integer: true
 		}),
-		pollTimeoutMs: readNumber(raw, "pollTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.pollTimeoutMs, {
+		pollTimeoutMs: readNumber(effective, "pollTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.pollTimeoutMs, {
 			min: 1e4,
 			max: 72e5,
 			integer: true
 		}),
-		requestTimeoutMs: readNumber(raw, "requestTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.requestTimeoutMs, {
+		requestTimeoutMs: readNumber(effective, "requestTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.requestTimeoutMs, {
 			min: 1e3,
 			max: 3e5,
 			integer: true
 		}),
-		uploadTimeoutMs: readNumber(raw, "uploadTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.uploadTimeoutMs, {
+		uploadTimeoutMs: readNumber(effective, "uploadTimeoutMs", KNOWHERE_PLUGIN_DEFAULTS.uploadTimeoutMs, {
 			min: 1e3,
 			max: 72e5,
 			integer: true
 		})
 	};
+	if (hasExplicit) persistResolvedConfig(stateDir, {
+		scopeMode: config.scopeMode,
+		storageDir: config.storageDir,
+		knowledgeGraph: raw.knowledgeGraph
+	}).catch(() => void 0);
+	return config;
 }
 const API_KEY_URL = "https://knowhereto.ai/api-keys";
 const PURCHASE_CREDITS_URL = "https://knowhereto.ai/usage?buy=true";
@@ -257,4 +305,4 @@ function resolveKnowledgeGraphConfig(raw) {
 	};
 }
 //#endregion
-export { assertKnowhereApiKey, formatPaymentRequiredMessage, isPaymentRequiredError, knowherePluginConfigSchema, persistApiKey, readPersistedApiKey, resolveKnowhereConfig, resolveKnowledgeGraphConfig };
+export { assertKnowhereApiKey, formatPaymentRequiredMessage, isPaymentRequiredError, knowherePluginConfigSchema, persistApiKey, readPersistedApiKey, resolveEffectivePluginConfig, resolveKnowhereConfig, resolveKnowledgeGraphConfig };

package/dist/connect-builder.d.ts

@@ -12,6 +12,8 @@ export interface ChunkData {
     chunk_id: string;
     path: string;
     content: string;
+    /** Document directory name (e.g. "report.pdf"). Injected by kg-service at load time. */
+    fileKey: string;
     metadata: {
         keywords?: string[];
         tokens?: string[];

package/dist/connect-builder.js

@@ -8,15 +8,14 @@ function normalizeKeyword(keyword) {
 	return keyword.toLowerCase().trim();
 }
 /**
-* Extract file key from a chunk path
-* Equivalent to Python: _extract_file_key
-*
-* Example: "Default_Root/report.docx/Chapter 1" -> "report.docx"
+* Extract file key from a chunk.
+* Prefers the explicit fileKey field; falls back to path-based extraction for backward compatibility.
 */
-function extractFileKey(path) {
-	const parts = path.split("/");
+function getFileKey(chunk) {
+	if (chunk.fileKey) return chunk.fileKey;
+	const parts = chunk.path.replace(/-->/g, "/").split("/");
 	if (parts.length >= 2) return parts[1];
-	return path;
+	return chunk.path;
 }
 /**
 * Build inverted keyword index: keyword -> [chunk_ids]
@@ -97,7 +96,7 @@ function buildConnections(chunks, config, logger) {
 	for (const chunk of chunks) chunkById.set(chunk.chunk_id, chunk);
 	const chunksByFile = /* @__PURE__ */ new Map();
 	for (const chunk of chunks) {
-		const fileKey = extractFileKey(chunk.path);
+		const fileKey = getFileKey(chunk);
 		if (!chunksByFile.has(fileKey)) chunksByFile.set(fileKey, /* @__PURE__ */ new Set());
 		chunksByFile.get(fileKey).add(chunk.chunk_id);
 	}
@@ -120,14 +119,14 @@ function buildConnections(chunks, config, logger) {
 		const sourceChunk = chunkById.get(sourceId);
 		if (!sourceChunk) continue;
 		const sourceKeywords = getKeywords(sourceChunk);
-		const sourceFileKey = extractFileKey(sourceChunk.path);
+		const sourceFileKey = getFileKey(sourceChunk);
 		for (const targetId of targetIds) {
 			const targetChunk = chunkById.get(targetId);
 			if (!targetChunk) continue;
 			const pairKey = sourceId < targetId ? `${sourceId}::${targetId}` : `${targetId}::${sourceId}`;
 			if (seenPairs.has(pairKey)) continue;
 			seenPairs.add(pairKey);
-			const targetFileKey = extractFileKey(targetChunk.path);
+			const targetFileKey = getFileKey(targetChunk);
 			if (config.crossFileOnly && sourceFileKey === targetFileKey) continue;
 			const contentRatio = sequenceMatcherRatio(sourceChunk.content.slice(0, 500), targetChunk.content.slice(0, 500));
 			if (contentRatio >= config.maxContentOverlap) {

package/dist/graph-builder.d.ts

@@ -32,12 +32,15 @@ interface FileMetadata {
     top_keywords: string[];
     top_summary: string;
     importance: number;
+    created_at: string;
 }
 /**
  * Complete knowledge graph structure
  */
 export interface KnowledgeGraph {
     version: string;
+    updated_at: string;
+    kb_id: string;
     stats: {
         total_files: number;
         total_chunks: number;
@@ -59,7 +62,7 @@ export interface ChunkStats {
  * 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;
+export declare function buildKnowledgeGraph(chunks: ChunkData[], connections: Connection[], chunkStats: ChunkStats, _jiebaInitialized: boolean, logger?: PluginLogger, kbId?: string): KnowledgeGraph;
 /**
  * Incremental update: match new chunks against existing chunks
  * Equivalent to Python: _incremental_connections

package/dist/graph-builder.js

@@ -1,18 +1,13 @@
-import * as nodejieba from "nodejieba";
 //#region src/graph-builder.ts
 /**
-* 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
+* Extract file key from a chunk.
+* Prefers the explicit fileKey field; falls back to path-based extraction for backward compatibility.
 */
-function extractFileKey(path) {
-	const parts = path.split("/");
+function getFileKey(chunk) {
+	if (chunk.fileKey) return chunk.fileKey;
+	const parts = chunk.path.replace(/-->/g, "/").split("/");
 	if (parts.length >= 2) return parts[1];
-	return path;
+	return chunk.path;
 }
 /**
 * Extract label from chunk path (last segment)
@@ -25,29 +20,18 @@ function extractLabel(path) {
 * Extract tokens from text using jieba
 * Equivalent to Python: _extract_tokens_from_content
 */
-function extractTokensFromContent(content, jiebaInitialized) {
-	const cleanContent = content.replace(/<[^>]*>/g, " ");
-	if (!jiebaInitialized) return cleanContent.split(/\s+/).filter((w) => w.length > 1);
-	try {
-		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 {
-		return cleanContent.split(/\s+/).filter((w) => w.length > 1);
-	}
+function extractTokensFromContent(content) {
+	return content.replace(/<[^>]*>/g, " ").split(/\s+/).filter((w) => w.length > 1);
 }
 /**
 * Compute TF-IDF top keywords for a file
 * Equivalent to Python: _compute_tfidf_top_keywords
 */
-function computeTfidfTopKeywords(fileChunks, allChunks, topK, jiebaInitialized) {
+function computeTfidfTopKeywords(fileChunks, allChunks, topK) {
 	if (fileChunks.length === 0) return [];
 	const fileTokens = [];
 	for (const chunk of fileChunks) {
-		const tokens = extractTokensFromContent(chunk.content, jiebaInitialized);
+		const tokens = extractTokensFromContent(chunk.content);
 		fileTokens.push(...tokens);
 	}
 	if (fileTokens.length === 0) return [];
@@ -58,7 +42,7 @@ function computeTfidfTopKeywords(fileChunks, allChunks, topK, jiebaInitialized)
 	}
 	const docFreq = /* @__PURE__ */ new Map();
 	for (const chunk of allChunks) {
-		const tokens = new Set(extractTokensFromContent(chunk.content, jiebaInitialized).map((t) => t.toLowerCase()));
+		const tokens = new Set(extractTokensFromContent(chunk.content).map((t) => t.toLowerCase()));
 		for (const token of tokens) docFreq.set(token, (docFreq.get(token) || 0) + 1);
 	}
 	const totalDocs = allChunks.length;
@@ -107,7 +91,7 @@ function computeFileImportance(fileKey, fileChunks, allChunks, chunkStats, decay
 function getAllChunkCountsByFile(chunks) {
 	const countsByFile = /* @__PURE__ */ new Map();
 	for (const chunk of chunks) {
-		const fileKey = extractFileKey(chunk.path);
+		const fileKey = getFileKey(chunk);
 		countsByFile.set(fileKey, (countsByFile.get(fileKey) || 0) + 1);
 	}
 	return Array.from(countsByFile.values());
@@ -122,8 +106,8 @@ function aggregateFileLevelEdges(connections, chunkById, topN = 5) {
 		const sourceChunk = chunkById.get(conn.source);
 		const targetChunk = chunkById.get(conn.target);
 		if (!sourceChunk || !targetChunk) continue;
-		const sourceFile = extractFileKey(sourceChunk.path);
-		const targetFile = extractFileKey(targetChunk.path);
+		const sourceFile = getFileKey(sourceChunk);
+		const targetFile = getFileKey(targetChunk);
 		if (sourceFile === targetFile) continue;
 		const pairKey = sourceFile < targetFile ? `${sourceFile}::${targetFile}` : `${targetFile}::${sourceFile}`;
 		if (!filePairs.has(pairKey)) filePairs.set(pairKey, []);
@@ -159,13 +143,13 @@ function aggregateFileLevelEdges(connections, chunkById, topN = 5) {
 * Main function to build knowledge graph
 * Equivalent to Python: build_knowledge_graph
 */
-function buildKnowledgeGraph(chunks, connections, chunkStats, jiebaInitialized, logger) {
+function buildKnowledgeGraph(chunks, connections, chunkStats, _jiebaInitialized, logger, kbId) {
 	logger?.info(`Building knowledge graph from ${chunks.length} chunks and ${connections.length} connections`);
 	const chunkById = /* @__PURE__ */ new Map();
 	for (const chunk of chunks) chunkById.set(chunk.chunk_id, chunk);
 	const chunksByFile = /* @__PURE__ */ new Map();
 	for (const chunk of chunks) {
-		const fileKey = extractFileKey(chunk.path);
+		const fileKey = getFileKey(chunk);
 		if (!chunksByFile.has(fileKey)) chunksByFile.set(fileKey, []);
 		chunksByFile.get(fileKey).push(chunk);
 	}
@@ -176,7 +160,7 @@ function buildKnowledgeGraph(chunks, connections, chunkStats, jiebaInitialized,
 			const type = chunk.metadata.type || "text";
 			typeCount[type] = (typeCount[type] || 0) + 1;
 		}
-		const topKeywords = computeTfidfTopKeywords(fileChunks, chunks, 10, jiebaInitialized);
+		const topKeywords = computeTfidfTopKeywords(fileChunks, chunks, 10);
 		const importance = computeFileImportance(fileKey, fileChunks, chunks, chunkStats);
 		let topSummary = "";
 		for (const chunk of fileChunks) if (chunk.metadata.summary && typeof chunk.metadata.summary === "string") {
@@ -188,13 +172,16 @@ function buildKnowledgeGraph(chunks, connections, chunkStats, jiebaInitialized,
 			types: typeCount,
 			top_keywords: topKeywords,
 			top_summary: topSummary,
-			importance
+			importance,
+			created_at: (/* @__PURE__ */ new Date()).toISOString()
 		};
 	}
 	const fileEdges = aggregateFileLevelEdges(connections, chunkById, 5);
 	logger?.info(`Created graph with ${Object.keys(filesMetadata).length} files and ${fileEdges.length} edges`);
 	return {
 		version: "2.0",
+		updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+		kb_id: kbId || "",
 		stats: {
 			total_files: Object.keys(filesMetadata).length,
 			total_chunks: chunks.length,

package/dist/index.js

@@ -1,4 +1,4 @@
-import { knowherePluginConfigSchema, readPersistedApiKey, resolveKnowhereConfig, resolveKnowledgeGraphConfig } from "./config.js";
+import { knowherePluginConfigSchema, readPersistedApiKey, resolveEffectivePluginConfig, resolveKnowhereConfig, resolveKnowledgeGraphConfig } from "./config.js";
 import { KnowhereStore } from "./store.js";
 import { createKnowhereToolFactory } from "./tools.js";
 import { KnowledgeGraphService } from "./kg-service.js";
@@ -6,11 +6,11 @@ import { KnowledgeGraphService } from "./kg-service.js";
 const plugin = {
 	id: "knowhere-claw",
 	name: "Knowhere",
-	description: "Knowhere document ingestion and direct stored-result access for OpenClaw.",
+	description: "Knowhere document ingestion, job management, and knowledge graph tools for OpenClaw.",
 	configSchema: knowherePluginConfigSchema,
 	register(api) {
 		const config = resolveKnowhereConfig(api);
-		const kgConfig = resolveKnowledgeGraphConfig(api.pluginConfig && typeof api.pluginConfig === "object" ? api.pluginConfig : {});
+		const kgConfig = resolveKnowledgeGraphConfig(resolveEffectivePluginConfig(api));
 		const store = new KnowhereStore({
 			rootDir: config.storageDir,
 			scopeMode: config.scopeMode,
@@ -41,12 +41,6 @@ const plugin = {
 			"knowhere_list_jobs",
 			"knowhere_get_job_status",
 			"knowhere_import_completed_job",
-			"knowhere_grep",
-			"knowhere_read_result_file",
-			"knowhere_preview_document",
-			"knowhere_list_documents",
-			"knowhere_remove_document",
-			"knowhere_clear_scope",
 			"knowhere_set_api_key",
 			"knowhere_kg_list",
 			"knowhere_kg_query"

package/dist/kg-service.d.ts

@@ -9,11 +9,9 @@ export declare class KnowledgeGraphService {
     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;

package/dist/kg-service.js

@@ -1,10 +1,10 @@
+import { resolveStoredKnowhereResultRoot } from "./parser.js";
 import { buildConnections, init_connect_builder } from "./connect-builder.js";
 import { buildKnowledgeGraph } from "./graph-builder.js";
 import path from "node:path";
+import os from "node:os";
 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
 init_connect_builder();
 const DEFAULT_CONNECT_CONFIG = {
@@ -25,18 +25,11 @@ const DEFAULT_KG_CONFIG = {
 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;
 	degradationMode = "full";
 	buildQueues = /* @__PURE__ */ new Map();
-	jiebaInitialized = false;
 	constructor(params) {
 		this.config = {
 			...DEFAULT_KG_CONFIG,
@@ -57,18 +50,12 @@ var KnowledgeGraphService = class {
 		}
 		try {
 			await this.checkPythonEnvironment();
-			await this.initializeJieba();
 			this.degradationMode = "full";
 			this.logger.info("Knowledge graph service initialized in full mode");
 		} catch (error) {
 			this.logger.warn(`Knowledge graph initialization failed: ${error instanceof Error ? error.message : String(error)}`);
-			if (error.code === "PYTHON_MISSING") {
-				this.degradationMode = "disabled";
-				this.logger.warn("Python not found, knowledge graph disabled");
-			} else if (error.code === "NODEJIEBA_MISSING") {
-				this.degradationMode = "basic";
-				this.logger.warn("Nodejieba missing, using basic tokenization");
-			} else this.degradationMode = "disabled";
+			this.degradationMode = "disabled";
+			this.logger.warn("Python not found, knowledge graph disabled");
 		}
 	}
 	async checkPythonEnvironment() {
@@ -91,30 +78,8 @@ var KnowledgeGraphService = class {
 			});
 		});
 	}
-	async initializeJieba() {
-		try {
-			nodejieba.load();
-			this.jiebaInitialized = true;
-			this.logger.info("Nodejieba initialized successfully");
-		} catch {
-			const err = /* @__PURE__ */ new Error("Failed to initialize nodejieba");
-			err.code = "NODEJIEBA_MISSING";
-			throw err;
-		}
-	}
 	async extractKeywords(text, topK = 20) {
 		if (this.degradationMode === "disabled") return [];
-		if (this.degradationMode === "full" && this.jiebaInitialized) try {
-			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: ${formatUnknownError(error)}`);
-			this.degradationMode = "basic";
-		}
 		return text.split(/\s+/).filter((w) => w.length > 1).slice(0, topK);
 	}
 	resolveKbId(context) {
@@ -143,9 +108,8 @@ var KnowledgeGraphService = class {
 		const kbPath = await this.ensureKbDirectory(params.kbId);
 		const docDir = path.join(kbPath, params.docId);
 		await fs.ensureDir(docDir);
-		await fs.copy(params.sourcePath, docDir, { overwrite: true });
-		const keywordsPath = path.join(docDir, "keywords.json");
-		await fs.writeJSON(keywordsPath, params.keywords, { spaces: 2 });
+		const sourceResultRoot = await resolveStoredKnowhereResultRoot(params.sourcePath);
+		await fs.copy(sourceResultRoot, docDir, { overwrite: true });
 		const metadataPath = path.join(docDir, "metadata.json");
 		await fs.writeJSON(metadataPath, params.metadata, { spaces: 2 });
 		this.logger.info(`Document saved to knowledge base: kb=${params.kbId} doc=${params.docId}`);
@@ -174,7 +138,7 @@ var KnowledgeGraphService = class {
 			const docPath = path.join(kbPath, 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) {
+		if (docDirs.length < 1) {
 			this.logger.info(`Not enough documents for graph building (need >=2, have ${docDirs.length}), skipping`);
 			return;
 		}
@@ -185,7 +149,10 @@ var KnowledgeGraphService = class {
 				const chunksPath = path.join(kbPath, docDir, "chunks.json");
 				if (await fs.pathExists(chunksPath)) {
 					const chunksData = await fs.readJSON(chunksPath);
-					if (chunksData.chunks && Array.isArray(chunksData.chunks)) allChunks.push(...chunksData.chunks);
+					if (chunksData.chunks && Array.isArray(chunksData.chunks)) allChunks.push(...chunksData.chunks.map((c) => ({
+						...c,
+						fileKey: docDir
+					})));
 				}
 			}
 			if (allChunks.length === 0) {
@@ -198,7 +165,7 @@ var KnowledgeGraphService = class {
 			const chunkStatsPath = path.join(kbPath, "chunk_stats.json");
 			let chunkStats = {};
 			if (await fs.pathExists(chunkStatsPath)) chunkStats = await fs.readJSON(chunkStatsPath);
-			const knowledgeGraph = buildKnowledgeGraph(allChunks, connections, chunkStats, this.jiebaInitialized, this.logger);
+			const knowledgeGraph = buildKnowledgeGraph(allChunks, connections, chunkStats, false, this.logger, kbId);
 			const graphFile = path.join(kbPath, "knowledge_graph.json");
 			await fs.writeJSON(graphFile, knowledgeGraph, { spaces: 2 });
 			this.logger.info(`Knowledge graph saved to ${graphFile}`);

package/dist/parser.d.ts

@@ -1,16 +1,12 @@
-import type { KnowhereDownloadedResult, KnowhereManifest, KnowhereParseResult, KnowhereStatistics, StoredBrowseIndex, StoredChunk } from "./types";
+import type { KnowhereDownloadedResult, KnowhereManifest, KnowhereStatistics } 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 declare function resolveStoredKnowhereResultRoot(documentDir: string): Promise<string>;
+export declare function resolveStoredKnowhereArtifactPath(documentDir: string, entryPath: string): Promise<string>;
+export declare function readStoredKnowhereResultSummary(documentDir: string): Promise<KnowhereStoredResultSummary>;
 export {};