@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/llm-wiki/workbench/web/src/lib/drawer-state.ts

@@ -0,0 +1,79 @@
+import type { GraphOpenPagePayload, Selection } from "@llm-wiki/graph-engine";
+import type { ArtifactManifest } from "@/lib/api";
+
+interface PageState {
+	content?: string;
+	loading?: boolean;
+	error?: string | null;
+}
+
+export type DrawerState =
+	| { mode: "closed" }
+	| {
+			mode: "wiki";
+			path: string | null;
+			content: string;
+			loading: boolean;
+			error: string | null;
+		}
+	| {
+			mode: "artifacts";
+			artifacts: ArtifactManifest[];
+			activeArtifactId: string | null;
+		}
+	| {
+			mode: "graph-reader";
+			payload: GraphOpenPagePayload;
+			content: string;
+			loading: boolean;
+			error: string | null;
+		}
+	| {
+			mode: "graph-selection";
+			title: string;
+			selection: Selection;
+			freeText: string;
+		};
+
+export function closedDrawer(): DrawerState {
+	return { mode: "closed" };
+}
+
+export function wikiDrawer(path: string | null, state: PageState = {}): DrawerState {
+	return {
+		mode: "wiki",
+		path,
+		content: state.content ?? "",
+		loading: state.loading ?? false,
+		error: state.error ?? null,
+	};
+}
+
+export function artifactDrawer(artifacts: ArtifactManifest[], activeArtifactId: string | null): DrawerState {
+	return { mode: "artifacts", artifacts, activeArtifactId };
+}
+
+export function graphReaderDrawer(payload: GraphOpenPagePayload, state: PageState = {}): DrawerState {
+	return {
+		mode: "graph-reader",
+		payload,
+		content: state.content ?? "",
+		loading: state.loading ?? false,
+		error: state.error ?? null,
+	};
+}
+
+export function shouldApplyGraphReaderResult(current: DrawerState, payload: GraphOpenPagePayload): boolean {
+	return current.mode === "graph-reader"
+		&& current.payload.path === payload.path
+		&& current.payload.node.id === payload.node.id;
+}
+
+export function graphSelectionDrawer(selection: Selection, title: string, freeText = ""): DrawerState {
+	return {
+		mode: "graph-selection",
+		title,
+		selection,
+		freeText,
+	};
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/graph-reader.ts

@@ -0,0 +1,25 @@
+import { pageReaderActions, type GraphOpenPagePayload, type PageReaderActionId } from "@llm-wiki/graph-engine";
+
+export type GraphReaderActionId = PageReaderActionId;
+
+export interface GraphReaderAction {
+	id: GraphReaderActionId;
+	label: string;
+}
+
+export function graphReaderMetaItems(payload: GraphOpenPagePayload): string[] {
+	const items = [payload.node.typeLabel];
+	if (payload.node.date) items.push(payload.node.date);
+	if (payload.node.source) items.push(payload.node.source);
+	if (payload.node.type === "source" && payload.node.sourcePath) items.push(payload.node.sourcePath);
+	return items;
+}
+
+export function graphReaderActions(): GraphReaderAction[] {
+	return pageReaderActions();
+}
+
+export function graphReaderActionLabels(payload: GraphOpenPagePayload): string[] {
+	void payload;
+	return graphReaderActions().map((action) => action.label);
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/graph-selection-drawer.ts

@@ -0,0 +1,35 @@
+import type { Selection } from "@llm-wiki/graph-engine";
+
+export interface GraphSelectionFactView {
+	label: string;
+	value: number;
+}
+
+export interface GraphSelectionViewModel {
+	hint: string;
+	showFacts: boolean;
+	canExpandNeighbors: boolean;
+	facts: GraphSelectionFactView[];
+	actionLabels: string[];
+}
+
+export function graphSelectionViewModel(selection: Selection): GraphSelectionViewModel {
+	const showFacts = selection.nodeIds.length >= 2;
+	const facts: GraphSelectionFactView[] = showFacts
+		? [
+				{ label: "页", value: selection.facts.pageCount },
+				{ label: "链接", value: selection.facts.internalLinkCount },
+				{ label: "社区", value: selection.facts.communityCount },
+			]
+		: [];
+	if (showFacts && selection.facts.isolatedCount > 0) {
+		facts.push({ label: "孤立", value: selection.facts.isolatedCount });
+	}
+	return {
+		hint: "Shift+点击 增删节点",
+		showFacts,
+		canExpandNeighbors: selection.nodeIds.length === 1,
+		facts,
+		actionLabels: selection.actions?.map((action) => action.label) ?? [],
+	};
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/graph-selection.ts

@@ -0,0 +1,96 @@
+import { wikiPathForGraphNode, type GraphData, type Selection, type SelectionAction } from "@llm-wiki/graph-engine";
+
+export interface SelectionPromptPayload {
+	selection: Selection;
+	action: SelectionAction | null;
+	freeText: string;
+	expandedText: string;
+	displayText: string;
+}
+
+interface SelectionNodeInfo {
+	id: string;
+	label: string;
+	path: string;
+	community: string;
+}
+
+interface SelectionEdgeInfo {
+	from: string;
+	to: string;
+	type: string;
+}
+
+export function buildSelectionPromptPayload(
+	data: GraphData,
+	selection: Selection,
+	action: SelectionAction | null,
+	freeText = "",
+): SelectionPromptPayload {
+	const nodes = selectionNodes(data, selection);
+	const edges = selectionEdges(data, selection);
+	const title = selectionTitle(data, selection);
+	const actionLine = action ? `动作：${action.label}` : "动作：自由提问";
+	const freeLine = freeText.trim() ? `补充要求：${freeText.trim()}` : "";
+	const expandedText = [
+		`@[选区:${title} · ${selection.facts.pageCount}页]`,
+		actionLine,
+		freeLine,
+		"",
+		"选区结构事实：",
+		`- 页数：${selection.facts.pageCount}`,
+		`- 内部链接数：${selection.facts.internalLinkCount}`,
+		`- 社区数：${selection.facts.communityCount}`,
+		`- 孤立数：${selection.facts.isolatedCount}`,
+		"",
+		"页面清单：",
+		...nodes.map((node, index) => `${index + 1}. [[${node.path}]] - ${node.label} - 社区 ${node.community}`),
+		"",
+		"链接关系：",
+		...(edges.length
+			? edges.map((edge) => `- ${edge.from} -> ${edge.to} (${edge.type})`)
+			: ["- 选区内没有直接链接"]),
+		"",
+		"请基于上面的选区信息回答；需要正文细节时，请按页面路径读取。"
+	].filter((line) => line !== undefined).join("\n");
+
+	return {
+		selection,
+		action,
+		freeText,
+		expandedText,
+		displayText: `@[选区:${title} · ${selection.facts.pageCount}页] ${action ? action.label : freeText.trim() || "自由提问"}`
+	};
+}
+
+export function selectionTitle(data: GraphData, selection: Selection): string {
+	if (selection.communityIds.length === 1) {
+		const community = data.learning?.communities?.find((item) => String(item.id) === selection.communityIds[0]);
+		if (community?.label) return community.label;
+	}
+	const firstNode = data.nodes.find((node) => selection.nodeIds.includes(node.id));
+	return firstNode?.label || selection.nodeIds[0] || "图谱";
+}
+
+function selectionNodes(data: GraphData, selection: Selection): SelectionNodeInfo[] {
+	const selected = new Set(selection.nodeIds);
+	return data.nodes
+		.filter((node) => selected.has(node.id))
+		.map((node) => ({
+			id: node.id,
+			label: node.label || node.id,
+			path: wikiPathForGraphNode(node),
+			community: String(node.community || "_none")
+		}));
+}
+
+function selectionEdges(data: GraphData, selection: Selection): SelectionEdgeInfo[] {
+	const selected = new Set(selection.nodeIds);
+	return data.edges
+		.filter((edge) => selected.has(edge.from) && selected.has(edge.to))
+		.map((edge) => ({
+			from: edge.from,
+			to: edge.to,
+			type: String(edge.type || "EXTRACTED")
+		}));
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/legacy-tool-status.ts

@@ -0,0 +1,113 @@
+import type { ToolStatusContractEvent } from "./api";
+import {
+	createToolStatusState,
+	reduceToolStatusEvent,
+	type ToolStatusState,
+} from "./tool-status-model";
+
+export interface LegacyToolMark {
+	name: string;
+	status: "done";
+}
+
+export function createLegacyToolStatusState(
+	messageId: string,
+	tools: LegacyToolMark[],
+): ToolStatusState | undefined {
+	if (tools.length === 0) return undefined;
+	let state = createToolStatusState(`legacy-${messageId}`, messageId, {
+		maxCompletedItems: 50,
+		maxSummaryItems: 8,
+	});
+	for (const [index, tool] of tools.entries()) {
+		const display = legacyToolDisplay(tool.name);
+		state = reduceToolStatusEvent(state, startEvent(state, display, index), { nowMs: index });
+		state = reduceToolStatusEvent(state, endEvent(state, display, tool.name, index), { nowMs: index });
+	}
+	return reduceToolStatusEvent(
+		state,
+		{
+			schemaVersion: 1,
+			type: "assistant_done",
+			runId: state.runId,
+			messageId: state.messageId,
+			seq: tools.length * 2 + 1,
+		},
+		{ nowMs: tools.length },
+	);
+}
+
+interface LegacyToolDisplay {
+	toolName: string;
+	action: string;
+	target: string;
+	args: Record<string, unknown>;
+}
+
+function startEvent(
+	state: ToolStatusState,
+	display: LegacyToolDisplay,
+	index: number,
+): Extract<ToolStatusContractEvent, { type: "tool_status_start" }> {
+	return {
+		schemaVersion: 1,
+		type: "tool_status_start",
+		runId: state.runId,
+		messageId: state.messageId,
+		seq: index * 2 + 1,
+		toolCallId: `legacy-${index}`,
+		toolName: display.toolName,
+		action: display.action,
+		target: display.target,
+		status: "running",
+		args: display.args,
+		runningToolCount: 1,
+		otherRunningCount: 0,
+	};
+}
+
+function endEvent(
+	state: ToolStatusState,
+	display: LegacyToolDisplay,
+	name: string,
+	index: number,
+): Extract<ToolStatusContractEvent, { type: "tool_status_end" }> {
+	return {
+		schemaVersion: 1,
+		type: "tool_status_end",
+		runId: state.runId,
+		messageId: state.messageId,
+		seq: index * 2 + 2,
+		toolCallId: `legacy-${index}`,
+		toolName: display.toolName,
+		action: display.action,
+		target: display.target,
+		status: "done",
+		result: null,
+		summary: name,
+		error: null,
+		durationMs: 0,
+		runningToolCount: 0,
+		otherRunningCount: 0,
+	};
+}
+
+function legacyToolDisplay(name: string): LegacyToolDisplay {
+	const lowerName = name.toLowerCase();
+	if (name.includes("读取") || lowerName.includes("read")) {
+		return { toolName: "read", action: "读取", target: name, args: { path: name } };
+	}
+	if (name.includes("写入") || lowerName.includes("write")) {
+		return { toolName: "write", action: "写入", target: name, args: { path: name } };
+	}
+	if (name.includes("搜索") || lowerName.includes("search")) {
+		return { toolName: "knowledge_search", action: "搜索", target: name, args: { query: name } };
+	}
+	if (name.includes("Skill") || lowerName.includes("skill")) {
+		return { toolName: "skill_runner", action: "调用 Skill", target: name, args: { skillName: name } };
+	}
+	if (lowerName.includes("bash") || lowerName.includes("command") || name.includes("命令")) {
+		return { toolName: "bash", action: "运行命令", target: name, args: { command: name } };
+	}
+	return { toolName: "legacy_tool", action: "工具", target: name, args: { name } };
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/sse.ts

@@ -0,0 +1,72 @@
+/**
+ * 极简 SSE parser，从 fetch 返回的 ReadableStream 里解析出 {event, data} 序列。
+ *
+ * 为什么不用 EventSource：EventSource 只支持 GET，我们的 /api/prompt 是 POST。
+ * 业界主流做法是 fetch + ReadableStream，自己解析 SSE 格式（spec 简单）。
+ *
+ * SSE 行格式（spec: https://html.spec.whatwg.org/multipage/server-sent-events.html）：
+ *   event: <name>
+ *   data: <payload>
+ *   <空行>
+ * 多行 data 会被合并（用换行连接）。
+ */
+
+export interface SSEMessage {
+	event: string;
+	data: string;
+}
+
+export async function* parseSSE(
+	stream: ReadableStream<Uint8Array>,
+): AsyncGenerator<SSEMessage, void, undefined> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder("utf-8");
+	let buffer = "";
+
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				// flush 剩余 buffer（理论上 server 用空行结尾，不会有残余）
+				if (buffer.trim()) {
+					const msg = parseBlock(buffer);
+					if (msg) yield msg;
+				}
+				return;
+			}
+			buffer += decoder.decode(value, { stream: true });
+
+			// 按 "\n\n" 切分消息块
+			while (true) {
+				const idx = buffer.indexOf("\n\n");
+				if (idx === -1) break;
+				const block = buffer.slice(0, idx);
+				buffer = buffer.slice(idx + 2);
+				const msg = parseBlock(block);
+				if (msg) yield msg;
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function parseBlock(block: string): SSEMessage | null {
+	let event = "message";
+	const dataLines: string[] = [];
+
+	for (const rawLine of block.split("\n")) {
+		const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+		if (!line || line.startsWith(":")) continue; // 注释或空行
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) continue;
+		const field = line.slice(0, colonIdx);
+		// SSE spec：":" 后若有一个空格，去掉它
+		const value = line.slice(colonIdx + 1).replace(/^ /, "");
+		if (field === "event") event = value;
+		else if (field === "data") dataLines.push(value);
+	}
+
+	if (dataLines.length === 0) return null;
+	return { event, data: dataLines.join("\n") };
+}

package/dist/skills/llm-wiki/workbench/web/src/lib/tool-status-format.ts

@@ -0,0 +1,170 @@
+export type ToolStatusGroup = "file" | "command" | "search" | "skill" | "other";
+
+export interface ToolStatusFormatInput {
+	toolName: string;
+	action?: string;
+	target?: string;
+	args?: Record<string, unknown>;
+	detail?: unknown;
+	homeDir?: string;
+	maxTargetLength?: number;
+}
+
+export interface ToolStatusFormatOutput {
+	action: string;
+	target: string;
+	group: ToolStatusGroup;
+}
+
+const DEFAULT_MAX_TARGET_LENGTH = 72;
+
+export function formatToolStatusItem(input: ToolStatusFormatInput): ToolStatusFormatOutput {
+	const toolName = input.toolName.trim() || "unknown_tool";
+	const lowerToolName = toolName.toLowerCase();
+	const merged = mergeRecords(toRecord(input.detail), toRecord(input.args));
+	const target = firstString(merged, [
+		"path",
+		"filePath",
+		"filepath",
+		"targetPath",
+		"target",
+		"absolutePath",
+		"relativePath",
+	]);
+	const query = firstString(merged, ["query", "pattern", "search", "term", "needle"]);
+	const command = firstString(merged, ["command", "cmd", "script"]);
+	const skill = firstString(merged, ["skill", "skillName", "name", "slug"]);
+	const maxLength = input.maxTargetLength ?? DEFAULT_MAX_TARGET_LENGTH;
+	const fallbackTarget = cleanString(input.target);
+
+	if (isFileTool(lowerToolName)) {
+		const action = lowerToolName.includes("edit") ? "编辑" : lowerToolName.includes("write") ? "写入" : "读取";
+		return {
+			action: cleanString(input.action) || action,
+			target: formatPathTarget(target ?? fallbackTarget, input.homeDir, maxLength),
+			group: "file",
+		};
+	}
+
+	if (isCommandTool(lowerToolName)) {
+		return {
+			action: cleanString(input.action) || "运行命令",
+			target: formatTextTarget(command ?? fallbackTarget, input.homeDir, maxLength, "未知命令"),
+			group: "command",
+		};
+	}
+
+	if (isSearchTool(lowerToolName)) {
+		const combined = query && target ? `${query} in ${target}` : query ?? target ?? fallbackTarget;
+		return {
+			action: cleanString(input.action) || "搜索",
+			target: formatTextTarget(combined, input.homeDir, maxLength, "未知搜索"),
+			group: "search",
+		};
+	}
+
+	if (isSkillTool(lowerToolName)) {
+		return {
+			action: cleanString(input.action) || "调用 Skill",
+			target: formatTextTarget(skill ?? fallbackTarget, input.homeDir, maxLength, "未知 Skill"),
+			group: "skill",
+		};
+	}
+
+	return {
+		action: cleanString(input.action) || `运行 ${toolName}`,
+		target: formatTextTarget(target ?? query ?? command ?? skill ?? fallbackTarget, input.homeDir, maxLength, "未知目标"),
+		group: "other",
+	};
+}
+
+export function truncateToolStatusText(value: string, maxLength = DEFAULT_MAX_TARGET_LENGTH): string {
+	if (maxLength <= 3) return value.slice(0, maxLength);
+	if (value.length <= maxLength) return value;
+	const keep = maxLength - 3;
+	const headLength = Math.max(1, Math.ceil(keep * 0.45));
+	const tailLength = Math.max(1, keep - headLength);
+	return `${value.slice(0, headLength)}...${value.slice(-tailLength)}`;
+}
+
+function formatPathTarget(
+	value: string | undefined,
+	homeDir: string | undefined,
+	maxLength: number,
+): string {
+	const redacted = redactPrivatePath(cleanString(value), homeDir);
+	if (!redacted) return "未知路径";
+	return compactPath(redacted, maxLength);
+}
+
+function formatTextTarget(
+	value: string | undefined,
+	homeDir: string | undefined,
+	maxLength: number,
+	emptyLabel: string,
+): string {
+	const redacted = redactPrivatePath(cleanString(value), homeDir);
+	if (!redacted) return emptyLabel;
+	return truncateToolStatusText(redacted, maxLength);
+}
+
+function compactPath(value: string, maxLength: number): string {
+	if (value.length <= maxLength) return value;
+	const normalized = value.replace(/\\/g, "/");
+	const parts = normalized.split("/").filter(Boolean);
+	if (parts.length <= 3) return truncateToolStatusText(normalized, maxLength);
+	const prefix = normalized.startsWith("~/") ? "~/" : normalized.startsWith("/") ? "/" : "";
+	const tail = parts.slice(-3).join("/");
+	const compacted = `${prefix}.../${tail}`;
+	return compacted.length <= maxLength ? compacted : truncateToolStatusText(compacted, maxLength);
+}
+
+function redactPrivatePath(value: string | undefined, homeDir: string | undefined): string {
+	if (!value) return "";
+	let redacted = value;
+	const normalizedHome = homeDir?.replace(/\/+$/, "");
+	if (normalizedHome) redacted = redacted.split(normalizedHome).join("~");
+	return redacted.replace(/\/Users\/[^/\s]+/g, "/Users/<user>");
+}
+
+function isFileTool(toolName: string): boolean {
+	return toolName.includes("read") || toolName.includes("write") || toolName.includes("edit");
+}
+
+function isCommandTool(toolName: string): boolean {
+	return toolName.includes("bash") || toolName.includes("shell") || toolName.includes("command");
+}
+
+function isSearchTool(toolName: string): boolean {
+	return toolName.includes("search") || toolName.includes("grep") || toolName.includes("find");
+}
+
+function isSkillTool(toolName: string): boolean {
+	return toolName.includes("skill");
+}
+
+function firstString(record: Record<string, unknown>, keys: string[]): string | undefined {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+	return undefined;
+}
+
+function mergeRecords(...records: Array<Record<string, unknown>>): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+	for (const record of records) {
+		const details = toRecord(record.details);
+		Object.assign(result, details, record);
+	}
+	return result;
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function cleanString(value: string | undefined): string | undefined {
+	const cleaned = value?.trim();
+	return cleaned ? cleaned : undefined;
+}