dsh-brief-sidebar 0.9.2 → 0.9.4

package/lib/index.mjs

@@ -5375,7 +5375,7 @@ function superRefine(fn, params) {
 * lists are capped; the uncapped `sessionTotal` keeps the summary truthful
 * beyond the cap.
 */
-const CAPS$1 = {
+const CAPS$2 = {
 	/** Latest-turn paths kept in the wire view. */
 	latest: 50,
 	/** Session-wide paths kept in the wire view (most recent win). */
@@ -5442,10 +5442,10 @@ function applyDeliverablesEvent(state, event) {
 	const latest = state.latest;
 	const nextLatest = latest !== null && latest.turn === recorded.turn && !latest.paths.includes(path) ? {
 		turn: latest.turn,
-		paths: [...latest.paths, path].slice(-CAPS$1.latest)
+		paths: [...latest.paths, path].slice(-CAPS$2.latest)
 	} : latest;
 	const withoutDuplicate = state.sessionPaths.filter((existing) => existing !== path);
-	const sessionPaths = [path, ...withoutDuplicate].slice(0, CAPS$1.session);
+	const sessionPaths = [path, ...withoutDuplicate].slice(0, CAPS$2.session);
 	const sessionTotal = withoutDuplicate.length === state.sessionPaths.length ? state.sessionTotal + 1 : state.sessionTotal;
 	return {
 		...state,
@@ -5509,7 +5509,7 @@ function isRecord(value) {
 * Capacity bounds. The unit rides every committed event, so the lists are
 * capped; `sessionTotal`/`callTotal` keep the summary truthful beyond the cap.
 */
-const CAPS = {
+const CAPS$1 = {
 	/** Distinct skills kept in state (most recent win). */
 	session: 50,
 	/** Skills kept in the latest-turn bucket of the wire view. */
@@ -5570,7 +5570,7 @@ function tally(state, skill, turn) {
 		name: skill,
 		count: (existing?.count ?? 0) + 1,
 		lastTurn: turn
-	}, ...withoutSkill].slice(0, CAPS.session);
+	}, ...withoutSkill].slice(0, CAPS$1.session);
 	const sessionTotal = existing === void 0 ? state.sessionTotal + 1 : state.sessionTotal;
 	const latest = state.latest;
 	const nextLatest = latest !== null && latest.turn === turn && !latest.names.includes(skill) ? {
@@ -5647,7 +5647,7 @@ function applySkillUsageEvent(state, event) {
 			}
 			return {
 				...state,
-				catalog: names.slice(0, CAPS.available),
+				catalog: names.slice(0, CAPS$1.available),
 				catalogCount: names.length
 			};
 		}
@@ -5663,6 +5663,199 @@ function applySkillUsageEvent(state, event) {
 	return tally(state, recorded.skill, recorded.turn);
 }
 //#endregion
+//#region src/projection/search-ref-fold.ts
+/**
+* Capacity bounds. `snippet` is capped because it is the only long text in the
+* state and the frame is republished per event; the provider already caps it
+* once in its own `presentationMeta`, so this is a second, tighter belt.
+*/
+const CAPS = {
+	/** Distinct sources kept in state. */
+	items: 20,
+	/** Distinct queries kept in state. */
+	queries: 20,
+	/** URLs kept in the latest-turn bucket. */
+	latest: 20,
+	/** Snippet characters kept per source. */
+	snippet: 160
+};
+/** The fold's initial state: no search has settled yet. */
+function initSearchRefState() {
+	return {
+		turn: 0,
+		calls: {},
+		latest: null,
+		items: [],
+		queries: [],
+		sourceTotal: 0,
+		queryTotal: 0
+	};
+}
+/** The tool this fold owns. Nothing else counts, even with a `query` argument. */
+const SEARCH_TOOL = "advanced_search";
+/**
+* Extract the query string from one committed `tool/call`.
+*
+* @param name - wire tool name.
+* @param argsRaw - model-produced JSON arguments (a string by the session contract).
+* @returns the non-blank query, or null when this call is not a search.
+*/
+function queryFromArgs(name, argsRaw) {
+	if (name !== SEARCH_TOOL) return null;
+	let args;
+	try {
+		args = JSON.parse(argsRaw);
+	} catch {
+		return null;
+	}
+	if (typeof args !== "object" || args === null || Array.isArray(args)) return null;
+	const query = args["query"];
+	return typeof query === "string" && query.trim().length > 0 ? query : null;
+}
+/**
+* The dedupe key. Host case and a trailing slash are not meaningful for
+* identity; path case IS, so it is left alone. Exported because the client
+* matches a row against the latest-turn bucket with the same algorithm.
+*/
+function urlKey(url) {
+	const trimmed = url.trim();
+	return (trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed).replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+/i, (match) => match.toLowerCase());
+}
+/** The host label of a URL, or the raw string when it does not parse. */
+function hostOf(url) {
+	try {
+		return new URL(url).hostname.replace(/^www\./i, "");
+	} catch {
+		return url.slice(0, 40);
+	}
+}
+/** Cap one snippet so one long provider blurb cannot dominate every frame. */
+function capSnippet(text) {
+	const one = text.replace(/\s+/g, " ").trim();
+	return one.length > CAPS.snippet ? `${one.slice(0, CAPS.snippet)}…` : one;
+}
+/** The sources of one result meta, or `[]` when the meta is absent or drifted. */
+function readSources(meta) {
+	if (typeof meta !== "object" || meta === null) return [];
+	const raw = meta["sources"];
+	if (!Array.isArray(raw)) return [];
+	const out = [];
+	for (const entry of raw) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		if (typeof record["url"] !== "string" || record["url"].trim().length === 0) continue;
+		const source = { url: record["url"] };
+		if (typeof record["title"] === "string" && record["title"].length > 0) source.title = record["title"];
+		if (typeof record["snippet"] === "string" && record["snippet"].length > 0) source.snippet = capSnippet(record["snippet"]);
+		out.push(source);
+	}
+	return out;
+}
+/**
+* The next state after one committed event. Events this fold does not own
+* return the SAME reference, which is what keeps the registry's `Object.is`
+* drive from republishing the key on unrelated frames.
+*
+* @param state - the state covering all prior events.
+* @param event - the next committed session event.
+* @returns the next state (same reference when nothing the fold tracks moved).
+*/
+function applySearchRefEvent(state, event) {
+	if (event.type === "turn/start") {
+		const turn = event.data;
+		if (typeof turn?.turn !== "number") return state;
+		const calls = {};
+		for (const [id, entry] of Object.entries(state.calls)) if (entry.turn >= turn.turn - 1) calls[id] = entry;
+		return {
+			...state,
+			turn: turn.turn,
+			calls,
+			latest: {
+				turn: turn.turn,
+				urls: []
+			}
+		};
+	}
+	if (event.type === "tool/call") {
+		const call = event.data;
+		if (typeof call?.callId !== "string") return state;
+		if (typeof call.name !== "string" || typeof call.arguments !== "string") return state;
+		const query = queryFromArgs(call.name, call.arguments);
+		if (query === null) return state;
+		return {
+			...state,
+			calls: {
+				...state.calls,
+				[call.callId]: {
+					turn: state.turn,
+					query
+				}
+			}
+		};
+	}
+	if (event.type !== "tool/result") return state;
+	const result = event.data;
+	const callId = result?.message?.source?.callId;
+	if (typeof callId !== "string") return state;
+	if (result?.message?.content?.[0]?.isError === true) return state;
+	const recorded = state.calls[callId];
+	if (recorded === void 0) return state;
+	const { query, turn } = recorded;
+	const sources = readSources(result.meta);
+	const items = [...state.items];
+	let sourceTotal = state.sourceTotal;
+	const urls = [];
+	for (const source of sources) {
+		const key = urlKey(source.url);
+		urls.push(key);
+		const at = items.findIndex((item) => urlKey(item.url) === key);
+		const row = {
+			url: source.url,
+			host: hostOf(source.url),
+			...source.title !== void 0 ? { title: source.title } : {},
+			...source.snippet !== void 0 ? { snippet: source.snippet } : {},
+			query,
+			count: at < 0 ? 1 : (items[at]?.count ?? 0) + 1,
+			lastTurn: turn
+		};
+		if (at >= 0) items.splice(at, 1);
+		else sourceTotal += 1;
+		items.unshift(row);
+	}
+	const queries = [...state.queries];
+	const qAt = queries.findIndex((row) => row.query === query);
+	let queryTotal = state.queryTotal;
+	if (qAt >= 0) {
+		const previous = queries[qAt];
+		queries.splice(qAt, 1);
+		queries.unshift({
+			query,
+			turn,
+			hits: (previous?.hits ?? 0) + sources.length
+		});
+	} else {
+		queries.unshift({
+			query,
+			turn,
+			hits: sources.length
+		});
+		queryTotal += 1;
+	}
+	const latest = state.latest;
+	const nextLatest = latest !== null && latest.turn === turn ? {
+		turn: latest.turn,
+		urls: [...urls.reverse(), ...latest.urls].slice(0, CAPS.latest)
+	} : latest;
+	return {
+		...state,
+		items: items.slice(0, CAPS.items),
+		queries: queries.slice(0, CAPS.queries),
+		sourceTotal,
+		queryTotal,
+		latest: nextLatest
+	};
+}
+//#endregion
 //#region src/projection/keys.ts
 /**
 * The projection keys this plugin contributes to the session-projection
@@ -5685,6 +5878,12 @@ const DELIVERABLES_KEY = "dshSummaryDeliverables";
 * to collide silently.
 */
 const SKILL_USAGE_KEY = "dshSummarySkillUsage";
+/**
+* The search-reference key (queries and returned sources of this session's
+* `advanced_search` calls). Same rule as above: the name is ours, so no other
+* host-side unit can answer for it by accident.
+*/
+const SEARCH_REFS_KEY = "dshSummarySearchRefs";
 //#endregion
 //#region src/projection/register.ts
 /**
@@ -5740,9 +5939,9 @@ function view(state) {
 	const next = {
 		latest: state.latest === null ? null : {
 			turn: state.latest.turn,
-			paths: state.latest.paths.slice(-CAPS$1.latest)
+			paths: state.latest.paths.slice(-CAPS$2.latest)
 		},
-		sessionPaths: state.sessionPaths.slice(0, CAPS$1.session),
+		sessionPaths: state.sessionPaths.slice(0, CAPS$2.session),
 		sessionTotal: state.sessionTotal
 	};
 	viewMemo.set(state, next);
@@ -5818,12 +6017,12 @@ function skillView(state) {
 	const next = {
 		latest: state.latest === null ? null : {
 			turn: state.latest.turn,
-			names: state.latest.names.slice(0, CAPS.latest)
+			names: state.latest.names.slice(0, CAPS$1.latest)
 		},
-		session: state.items.slice(0, CAPS.view),
+		session: state.items.slice(0, CAPS$1.view),
 		sessionTotal: state.sessionTotal,
 		callTotal: state.callTotal,
-		available: state.catalog.slice(0, CAPS.available),
+		available: state.catalog.slice(0, CAPS$1.available),
 		availableCount: state.catalogCount
 	};
 	skillViewMemo.set(state, next);
@@ -5851,6 +6050,98 @@ function registerSkillUsageProjection(ctx) {
 		});
 	});
 }
+/** Zod schema of the search-reference fold state. */
+const searchStateSchema = object({
+	turn: number(),
+	calls: record(string(), object({
+		turn: number(),
+		query: string()
+	})),
+	latest: object({
+		turn: number(),
+		urls: array(string())
+	}).nullable(),
+	items: array(object({
+		url: string(),
+		host: string(),
+		title: string().optional(),
+		snippet: string().optional(),
+		query: string(),
+		count: number(),
+		lastTurn: number()
+	})),
+	queries: array(object({
+		query: string(),
+		turn: number(),
+		hits: number()
+	})),
+	sourceTotal: number(),
+	queryTotal: number()
+});
+/** Zod schema of the search-reference wire view. */
+const searchViewSchema = object({
+	latest: object({
+		turn: number(),
+		urls: array(string())
+	}).nullable(),
+	queries: array(object({
+		query: string(),
+		turn: number(),
+		hits: number()
+	})),
+	sources: array(object({
+		url: string(),
+		host: string(),
+		title: string().optional(),
+		snippet: string().optional(),
+		query: string(),
+		count: number(),
+		lastTurn: number()
+	})),
+	queryTotal: number(),
+	sourceTotal: number()
+});
+/** Same reference-stability memo, for the search-reference unit. */
+const searchViewMemo = /* @__PURE__ */ new WeakMap();
+/** State → wire view, reference-stable across unchanged states. */
+function searchView(state) {
+	const memoized = searchViewMemo.get(state);
+	if (memoized !== void 0) return memoized;
+	const next = {
+		latest: state.latest === null ? null : {
+			turn: state.latest.turn,
+			urls: state.latest.urls.slice(0, CAPS.latest)
+		},
+		queries: state.queries.slice(0, CAPS.queries),
+		sources: state.items.slice(0, CAPS.items),
+		queryTotal: state.queryTotal,
+		sourceTotal: state.sourceTotal
+	};
+	searchViewMemo.set(state, next);
+	return next;
+}
+/**
+* Register the search-reference projection as an optional contribution.
+*
+* @param ctx - the host context the plugin's `apply` receives.
+*/
+function registerSearchRefProjection(ctx) {
+	ctx.inject(["sessionProjections"], (injected) => {
+		const registry = injected.sessionProjections;
+		if (registry === void 0 || typeof registry.register !== "function") return;
+		registry.register({
+			key: SEARCH_REFS_KEY,
+			stateSchema: searchStateSchema,
+			init: () => initSearchRefState(),
+			apply: applySearchRefEvent,
+			wire: {
+				viewSchema: searchViewSchema,
+				view: searchView
+			},
+			stateVersion: 0
+		});
+	});
+}
 //#endregion
 //#region src/index.ts
 /** Profile row identity. */
@@ -5880,6 +6171,7 @@ const Config = z.object({
 function apply(ctx) {
 	registerDeliverablesProjection(ctx);
 	registerSkillUsageProjection(ctx);
+	registerSearchRefProjection(ctx);
 }
 //#endregion
 export { Config, apply, name };