@research-copilot/plugin 1.1.17 → 1.1.19

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

@@ -0,0 +1,392 @@
+import type {
+	AssistantCancelledEvent,
+	AssistantErrorEvent,
+	ToolDisplay,
+	ToolRunStatus,
+	ToolStatusContractEvent,
+	ToolStatusEndEvent,
+	ToolStatusStartEvent,
+	ToolStatusSummaryEvent,
+	ToolStatusUpdateEvent,
+} from "./api";
+
+type CompletedStatus = Exclude<ToolRunStatus, "running">;
+
+export interface ToolStatusModelOptions {
+	coalesceMs?: number;
+	maxCompletedItems?: number;
+	maxSummaryItems?: number;
+}
+
+export interface ToolStatusReduceOptions {
+	nowMs: number;
+}
+
+export interface ToolStatusActiveItem extends ToolDisplay {
+	status: "running";
+	args: Record<string, unknown>;
+	detail?: unknown;
+	startSeq: number;
+	lastSeq: number;
+}
+
+export interface ToolStatusCompletedItem extends ToolDisplay {
+	status: CompletedStatus;
+	args: Record<string, unknown>;
+	summary: string | null;
+	error: string | null;
+	durationMs: number;
+	lastSeq: number;
+}
+
+export interface ToolStatusSummaryState {
+	items: Array<ToolDisplay & { status: CompletedStatus; summary: string | null }>;
+	remainingRunningCount: number;
+	overflowCount: number;
+	overflowLabel: string | null;
+}
+
+export interface IgnoredToolStatusEvent {
+	seq: number;
+	type: ToolStatusContractEvent["type"];
+	reason: "foreign-run" | "foreign-message" | "duplicate-or-late";
+}
+
+interface PendingToolUpdate {
+	event: ToolStatusUpdateEvent;
+	nowMs: number;
+}
+
+export interface ToolStatusState {
+	runId: string;
+	messageId: string;
+	active: ToolStatusActiveItem[];
+	completed: ToolStatusCompletedItem[];
+	failures: ToolStatusCompletedItem[];
+	summary: ToolStatusSummaryState;
+	ignored: IgnoredToolStatusEvent[];
+	isDone: boolean;
+	cancelReason: string | null;
+	error: string | null;
+	lastSeq: number;
+	coalesceMs: number;
+	nextUpdateFlushAt: number;
+	pendingUpdateCount: number;
+	completedOverflowCount: number;
+	completedOverflowLabel: string | null;
+	maxCompletedItems: number;
+	maxSummaryItems: number;
+	pendingUpdates: Record<string, PendingToolUpdate>;
+}
+
+const DEFAULT_COALESCE_MS = 100;
+const DEFAULT_MAX_COMPLETED_ITEMS = 20;
+const DEFAULT_MAX_SUMMARY_ITEMS = 8;
+
+export function createToolStatusState(
+	runId: string,
+	messageId: string,
+	options: ToolStatusModelOptions = {},
+): ToolStatusState {
+	return {
+		runId,
+		messageId,
+		active: [],
+		completed: [],
+		failures: [],
+		summary: {
+			items: [],
+			remainingRunningCount: 0,
+			overflowCount: 0,
+			overflowLabel: null,
+		},
+		ignored: [],
+		isDone: false,
+		cancelReason: null,
+		error: null,
+		lastSeq: 0,
+		coalesceMs: options.coalesceMs ?? DEFAULT_COALESCE_MS,
+		nextUpdateFlushAt: Number.POSITIVE_INFINITY,
+		pendingUpdateCount: 0,
+		completedOverflowCount: 0,
+		completedOverflowLabel: null,
+		maxCompletedItems: options.maxCompletedItems ?? DEFAULT_MAX_COMPLETED_ITEMS,
+		maxSummaryItems: options.maxSummaryItems ?? DEFAULT_MAX_SUMMARY_ITEMS,
+		pendingUpdates: {},
+	};
+}
+
+export function reduceToolStatusEvents(
+	state: ToolStatusState,
+	events: readonly ToolStatusContractEvent[],
+	options: ToolStatusReduceOptions,
+): ToolStatusState {
+	return events.reduce((nextState, event) => reduceToolStatusEvent(nextState, event, options), state);
+}
+
+export function reduceToolStatusEvent(
+	state: ToolStatusState,
+	event: ToolStatusContractEvent,
+	options: ToolStatusReduceOptions,
+): ToolStatusState {
+	const ignoredReason = getIgnoredReason(state, event);
+	if (ignoredReason) {
+		return {
+			...state,
+			ignored: [...state.ignored, { seq: event.seq, type: event.type, reason: ignoredReason }],
+		};
+	}
+
+	const acceptedState = { ...state, lastSeq: event.seq };
+	switch (event.type) {
+		case "tool_status_start":
+			return reduceStart(acceptedState, event, options.nowMs);
+		case "tool_status_update":
+			return reduceUpdate(acceptedState, event, options.nowMs);
+		case "tool_status_end":
+			return reduceEnd(acceptedState, event);
+		case "tool_status_summary":
+			return reduceSummary(acceptedState, event);
+		case "assistant_done":
+			return { ...acceptedState, active: [], pendingUpdates: {}, pendingUpdateCount: 0, isDone: true };
+		case "assistant_cancelled":
+			return reduceCancelled(acceptedState, event);
+		case "assistant_error":
+			return reduceError(acceptedState, event);
+		case "assistant_text_delta":
+			return acceptedState;
+		default:
+			return assertNever(event);
+	}
+}
+
+export function flushToolStatusUpdates(state: ToolStatusState, nowMs: number): ToolStatusState {
+	if (state.pendingUpdateCount === 0 || nowMs < state.nextUpdateFlushAt) return state;
+	let nextState = state;
+	for (const pending of Object.values(state.pendingUpdates)) {
+		nextState = applyUpdateToActive(nextState, pending.event, pending.nowMs);
+	}
+	return {
+		...nextState,
+		pendingUpdates: {},
+		pendingUpdateCount: 0,
+		nextUpdateFlushAt: nowMs + state.coalesceMs,
+	};
+}
+
+export function cancelActiveToolStatus(state: ToolStatusState, reason = "已停止"): ToolStatusState {
+	if (state.active.length === 0 && state.pendingUpdateCount === 0) {
+		return { ...state, isDone: true, cancelReason: reason };
+	}
+	const cancelledItems: ToolStatusCompletedItem[] = state.active.map((item) => ({
+		toolCallId: item.toolCallId,
+		toolName: item.toolName,
+		action: item.action,
+		target: item.target,
+		status: "cancelled",
+		args: item.args,
+		summary: reason,
+		error: null,
+		durationMs: 0,
+		lastSeq: item.lastSeq,
+	}));
+	const nextState = capCompleted({
+		...state,
+		active: [],
+		completed: [...state.completed, ...cancelledItems],
+		pendingUpdates: {},
+		pendingUpdateCount: 0,
+		isDone: true,
+		cancelReason: reason,
+	});
+	const summaryItems = nextState.completed.map((item) => ({
+		toolCallId: item.toolCallId,
+		toolName: item.toolName,
+		action: item.action,
+		target: item.target,
+		status: item.status,
+		summary: item.summary,
+	}));
+	const cappedItems = summaryItems.slice(0, nextState.maxSummaryItems);
+	const overflowCount = Math.max(0, summaryItems.length - cappedItems.length);
+	return {
+		...nextState,
+		summary: {
+			items: cappedItems,
+			remainingRunningCount: 0,
+			overflowCount,
+			overflowLabel: makeOverflowLabel(overflowCount),
+		},
+	};
+}
+
+function reduceStart(state: ToolStatusState, event: ToolStatusStartEvent, nowMs: number): ToolStatusState {
+	const active = withoutTool(state.active, event.toolCallId);
+	const nextItem: ToolStatusActiveItem = {
+		toolCallId: event.toolCallId,
+		toolName: event.toolName,
+		action: event.action,
+		target: event.target,
+		status: "running",
+		args: event.args ?? {},
+		startSeq: event.seq,
+		lastSeq: event.seq,
+	};
+	return {
+		...state,
+		active: [...active, nextItem],
+		nextUpdateFlushAt: Number.isFinite(state.nextUpdateFlushAt)
+			? state.nextUpdateFlushAt
+			: nowMs + state.coalesceMs,
+	};
+}
+
+function reduceUpdate(state: ToolStatusState, event: ToolStatusUpdateEvent, nowMs: number): ToolStatusState {
+	if (nowMs < state.nextUpdateFlushAt) {
+		const pendingUpdates = {
+			...state.pendingUpdates,
+			[event.toolCallId]: { event, nowMs },
+		};
+		return {
+			...state,
+			pendingUpdates,
+			pendingUpdateCount: state.pendingUpdateCount + 1,
+		};
+	}
+	return {
+		...applyUpdateToActive(state, event, nowMs),
+		nextUpdateFlushAt: nowMs + state.coalesceMs,
+	};
+}
+
+function applyUpdateToActive(
+	state: ToolStatusState,
+	event: ToolStatusUpdateEvent,
+	nowMs: number,
+): ToolStatusState {
+	const existing = state.active.find((item) => item.toolCallId === event.toolCallId);
+	const nextItem: ToolStatusActiveItem = {
+		toolCallId: event.toolCallId,
+		toolName: event.toolName,
+		action: event.action,
+		target: event.target,
+		status: "running",
+		args: Object.keys(event.args ?? {}).length > 0 ? event.args : existing?.args ?? {},
+		detail: event.detail,
+		startSeq: existing?.startSeq ?? event.seq,
+		lastSeq: event.seq,
+	};
+	return {
+		...state,
+		active: [...withoutTool(state.active, event.toolCallId), nextItem],
+		nextUpdateFlushAt: Number.isFinite(state.nextUpdateFlushAt)
+			? state.nextUpdateFlushAt
+			: nowMs + state.coalesceMs,
+	};
+}
+
+function reduceEnd(state: ToolStatusState, event: ToolStatusEndEvent): ToolStatusState {
+	const existing = state.active.find((item) => item.toolCallId === event.toolCallId);
+	const args = existing?.args ?? {};
+	const completedItem: ToolStatusCompletedItem = {
+		toolCallId: event.toolCallId,
+		toolName: event.toolName,
+		action: event.action,
+		target: event.target,
+		status: event.status,
+		args,
+		summary: event.summary,
+		error: event.error,
+		durationMs: event.durationMs,
+		lastSeq: event.seq,
+	};
+	return capCompleted({
+		...state,
+		active: withoutTool(state.active, event.toolCallId),
+		pendingUpdates: omitTool(state.pendingUpdates, event.toolCallId),
+		pendingUpdateCount: Object.keys(omitTool(state.pendingUpdates, event.toolCallId)).length,
+		completed: [...state.completed, completedItem],
+		failures: event.status === "failed" ? [...state.failures, completedItem] : state.failures,
+	});
+}
+
+function reduceSummary(state: ToolStatusState, event: ToolStatusSummaryEvent): ToolStatusState {
+	const cappedItems = event.items.slice(0, state.maxSummaryItems);
+	const overflowCount = Math.max(0, event.items.length - cappedItems.length);
+	return {
+		...state,
+		summary: {
+			items: cappedItems,
+			remainingRunningCount: event.remainingRunningCount,
+			overflowCount,
+			overflowLabel: makeOverflowLabel(overflowCount),
+		},
+	};
+}
+
+function reduceCancelled(state: ToolStatusState, event: AssistantCancelledEvent): ToolStatusState {
+	return {
+		...state,
+		active: [],
+		pendingUpdates: {},
+		pendingUpdateCount: 0,
+		isDone: true,
+		cancelReason: event.reason,
+	};
+}
+
+function reduceError(state: ToolStatusState, event: AssistantErrorEvent): ToolStatusState {
+	return {
+		...state,
+		active: [],
+		pendingUpdates: {},
+		pendingUpdateCount: 0,
+		isDone: true,
+		error: event.error,
+	};
+}
+
+function capCompleted(state: ToolStatusState): ToolStatusState {
+	const overflowCount = Math.max(0, state.completed.length - state.maxCompletedItems);
+	if (overflowCount === 0) {
+		return {
+			...state,
+			completedOverflowCount: 0,
+			completedOverflowLabel: null,
+		};
+	}
+	return {
+		...state,
+		completed: state.completed.slice(overflowCount),
+		completedOverflowCount: state.completedOverflowCount + overflowCount,
+		completedOverflowLabel: makeOverflowLabel(state.completedOverflowCount + overflowCount),
+	};
+}
+
+function getIgnoredReason(
+	state: ToolStatusState,
+	event: ToolStatusContractEvent,
+): IgnoredToolStatusEvent["reason"] | null {
+	if (event.runId !== state.runId) return "foreign-run";
+	if (event.messageId !== state.messageId) return "foreign-message";
+	if (event.seq <= state.lastSeq) return "duplicate-or-late";
+	return null;
+}
+
+function withoutTool<T extends ToolDisplay>(items: readonly T[], toolCallId: string): T[] {
+	return items.filter((item) => item.toolCallId !== toolCallId);
+}
+
+function omitTool<T>(items: Record<string, T>, toolCallId: string): Record<string, T> {
+	const nextItems = { ...items };
+	delete nextItems[toolCallId];
+	return nextItems;
+}
+
+function makeOverflowLabel(count: number): string | null {
+	return count > 0 ? `还有 ${count} 项` : null;
+}
+
+function assertNever(value: never): never {
+	throw new Error(`Unsupported tool status event: ${JSON.stringify(value)}`);
+}

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

@@ -0,0 +1,10 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+/**
+ * 合并 className 的工具函数（shadcn 标准）
+ * 用法：cn("base-class", condition && "extra-class", className)
+ */
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}

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

@@ -0,0 +1,32 @@
+export const WIKI_LINK_SEEN_EVENT = "llm-wiki-agent:wiki-link-seen";
+
+export function extractWikiPageRefs(content: string): string[] {
+	const seen = new Set<string>();
+	const refs: string[] = [];
+	const patterns = [
+		/\[\[(wiki\/[^\]\n]+?\.md)\]\]/g,
+		/\]\((wiki\/[^)\n]+?\.md)\)/g
+	];
+	for (const pattern of patterns) {
+		addMatches(content, pattern, seen, refs);
+	}
+	return refs;
+}
+
+function addMatches(content: string, pattern: RegExp, seen: Set<string>, refs: string[]): void {
+	for (const match of content.matchAll(pattern)) {
+		const target = match[1];
+		if (seen.has(target)) continue;
+		seen.add(target);
+		refs.push(target);
+	}
+}
+
+export function normalizeWikiLinks(content: string): string {
+	return content.replace(/\[\[(wiki\/[^\]\n]+?\.md)\]\]/g, (_match, target: string) => `[${target}](${target})`);
+}
+
+export function emitWikiLinkSeen(path: string): void {
+	if (typeof window === "undefined") return;
+	window.dispatchEvent(new CustomEvent<string>(WIKI_LINK_SEEN_EVENT, { detail: path }));
+}

package/dist/skills/llm-wiki/workbench/web/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

package/dist/skills/llm-wiki/workbench/web/test/api.test.ts

@@ -0,0 +1,61 @@
+import { afterEach, describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+	getGraphData,
+	getGraphLayout,
+	putGraphLayout,
+	rebuildGraph,
+} from "../src/lib/api";
+
+describe("graph API helpers", () => {
+	const originalFetch = globalThis.fetch;
+
+	afterEach(() => {
+		globalThis.fetch = originalFetch;
+	});
+
+	it("binds graph reads, rebuilds, and layout writes to the requested knowledge base", async () => {
+		const requests: Array<{ url: string; method: string; body?: BodyInit | null }> = [];
+		const responses: unknown[] = [
+			{ ok: true, needsBuild: true, graphPath: "/kb/wiki/graph-data.json" },
+			{ ok: true, layoutPath: "/kb/.wiki-graph-layout.json", layout: { version: 1, pins: {}, updatedAt: "" } },
+			{ ok: true, status: "started" },
+			{ ok: true, layoutPath: "/kb/.wiki-graph-layout.json", layout: { version: 1, pins: {}, updatedAt: "" } },
+		];
+		globalThis.fetch = (async (input, init) => {
+			requests.push({
+				url: String(input),
+				method: init?.method ?? "GET",
+				body: init?.body,
+			});
+			return new Response(JSON.stringify(responses.shift()), {
+				headers: { "Content-Type": "application/json" },
+			});
+		}) as typeof fetch;
+
+		const kbPath = "/tmp/Knowledge Base";
+		await getGraphData(kbPath);
+		await getGraphLayout(kbPath);
+		await rebuildGraph(kbPath);
+		await putGraphLayout(kbPath, { "wiki/a.md": { x: 1, y: 2 } });
+
+		assert.deepEqual(
+			requests.map((request) => request.url),
+			[
+				"/api/graph?kb=%2Ftmp%2FKnowledge%20Base",
+				"/api/graph/layout?kb=%2Ftmp%2FKnowledge%20Base",
+				"/api/graph/rebuild?kb=%2Ftmp%2FKnowledge%20Base",
+				"/api/graph/layout?kb=%2Ftmp%2FKnowledge%20Base",
+			],
+		);
+		assert.deepEqual(
+			requests.map((request) => request.method),
+			["GET", "GET", "POST", "PUT"],
+		);
+		assert.deepEqual(JSON.parse(String(requests[3]?.body)), {
+			version: 1,
+			pins: { "wiki/a.md": { x: 1, y: 2 } },
+		});
+	});
+});

package/dist/skills/llm-wiki/workbench/web/test/chat-panel-tool-status.test.tsx

@@ -0,0 +1,26 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { ToolHistorySummary } from "../src/components/ToolHistorySummary";
+import { createLegacyToolStatusState } from "../src/lib/legacy-tool-status";
+
+describe("ChatPanel tool status rendering", () => {
+	it("renders legacy historical tool calls as a folded summary instead of the old live list", () => {
+		const state = createLegacyToolStatusState("a-history", [
+			{ name: "读取 ~/wiki/index.md：读取完成", status: "done" },
+			{ name: "历史工具调用：bash", status: "done" },
+		]);
+		assert.ok(state);
+
+		const html = renderToStaticMarkup(React.createElement(ToolHistorySummary, { state }));
+
+		assert.match(html, /tool-history-summary/);
+		assert.match(html, /工具摘要/);
+		assert.match(html, /文件 1/);
+		assert.match(html, /命令 1/);
+		assert.equal(html.includes("msg-tools"), false);
+		assert.equal(html.includes("tool-runway"), false);
+	});
+});

package/dist/skills/llm-wiki/workbench/web/test/graph-drawer-state.test.ts

@@ -0,0 +1,78 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import type { GraphOpenPagePayload, Selection } from "@llm-wiki/graph-engine";
+import {
+	artifactDrawer,
+	closedDrawer,
+	graphReaderDrawer,
+	graphSelectionDrawer,
+	wikiDrawer,
+} from "../src/lib/drawer-state";
+
+describe("drawer state", () => {
+	it("creates mutually exclusive closed, wiki, artifact, and graph reader states", () => {
+		const payload = graphPayload();
+
+		assert.deepEqual(closedDrawer(), { mode: "closed" });
+		assert.deepEqual(wikiDrawer("wiki/topics/a.md", { loading: true }), {
+			mode: "wiki",
+			path: "wiki/topics/a.md",
+			content: "",
+			loading: true,
+			error: null,
+		});
+		assert.deepEqual(artifactDrawer([], "artifact-1"), {
+			mode: "artifacts",
+			artifacts: [],
+			activeArtifactId: "artifact-1",
+		});
+		assert.deepEqual(graphReaderDrawer(payload, { content: "# Alpha" }), {
+			mode: "graph-reader",
+			payload,
+			content: "# Alpha",
+			loading: false,
+			error: null,
+		});
+		assert.deepEqual(graphSelectionDrawer(selectionFixture(), "Alpha", "note"), {
+			mode: "graph-selection",
+			title: "Alpha",
+			selection: selectionFixture(),
+			freeText: "note",
+		});
+	});
+});
+
+function graphPayload(): GraphOpenPagePayload {
+	return {
+		path: "wiki/topics/a.md",
+		node: {
+			id: "a",
+			title: "Alpha",
+			type: "topic",
+			typeLabel: "主题",
+			sourcePath: "wiki/topics/a.md",
+			community: "alpha",
+			date: "2026-06-13",
+			source: "Archive",
+			isolated: false,
+		},
+	};
+}
+
+function selectionFixture(): Selection {
+	return {
+		id: "selection-test",
+		nodeIds: ["a"],
+		communityIds: [],
+		facts: {
+			pageCount: 1,
+			internalLinkCount: 0,
+			communityCount: 1,
+			isolatedCount: 0,
+		},
+		actions: [
+			{ id: "summarize_page", label: "总结这一页", tone: "digest" },
+		],
+	};
+}

package/dist/skills/llm-wiki/workbench/web/test/graph-reader-request.test.ts

@@ -0,0 +1,32 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import type { GraphOpenPagePayload } from "@llm-wiki/graph-engine";
+import { graphReaderDrawer, shouldApplyGraphReaderResult } from "../src/lib/drawer-state";
+
+describe("graph reader async request guards", () => {
+	it("only applies a page read result to the matching open graph reader", () => {
+		const first = graphPayload("a", "wiki/entities/A.md");
+		const second = graphPayload("b", "wiki/entities/B.md");
+
+		assert.equal(shouldApplyGraphReaderResult(graphReaderDrawer(first, { loading: true }), first), true);
+		assert.equal(shouldApplyGraphReaderResult(graphReaderDrawer(second, { loading: true }), first), false);
+	});
+});
+
+function graphPayload(id: string, path: string): GraphOpenPagePayload {
+	return {
+		path,
+		node: {
+			id,
+			title: id.toUpperCase(),
+			type: "entity",
+			typeLabel: "实体",
+			sourcePath: path,
+			community: "test",
+			date: null,
+			source: null,
+			isolated: false,
+		},
+	};
+}