dsh-context 0.35.0 → 0.37.0

package/lib/index.js

@@ -1,7 +1,247 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 import z$1 from "@deepseek-ai/schemastery";
 import { deriveEventMessage } from "@deepseek-ai/dsh-session";
+/**
+* Recover the MCP server display label from a proxied tool name, or undefined
+* for non-MCP names. `dsh-mcp-client` names tools `mcp__<server>__<rawName>`
+* (normalized, and hash-appended when overlong/invalid — the label then shows
+* whatever of the server survived the truncation). The separating `__` is the
+* LAST one in the name, and it must sit AFTER the `mcp__` prefix: the prefix's
+* own separator (or an empty server right after it) is not a server.
+*/
+function mcpServerOf(name) {
+	if (!name.startsWith("mcp__")) return void 0;
+	const cut = name.lastIndexOf("__");
+	if (cut < 5) return void 0;
+	const server = name.slice(5, cut);
+	return server.length > 0 ? server : void 0;
+}
+/** The `mcp:<server>` display label of a proxied tool name, or undefined. */
+function mcpSourceOf(name) {
+	const server = mcpServerOf(name);
+	return server !== void 0 ? `mcp:${server}` : void 0;
+}
+/** The pinned package of a first-party tool name, or undefined. */
+function pinnedSourceOf(name) {
+	return FIRST_PARTY_SOURCES[name];
+}
+/**
+* Pinned first-party tool → plugin package map (see header comment). One entry
+* per model-facing name of the shipped tool packages at dsh 0.1.1-rc.2, from
+* the official tool-schema catalog; names are stable across the supported
+* harness range. Packages that mount under distinct names per composition
+* (bash/pwsh persistent variants, subagent fork) map to their primary package.
+*/
+const FIRST_PARTY_SOURCES = Object.freeze({
+	read: "@deepseek-ai/dsh-tool-fs",
+	write: "@deepseek-ai/dsh-tool-fs",
+	edit: "@deepseek-ai/dsh-tool-fs",
+	read_image: "@deepseek-ai/dsh-tool-fs",
+	glob: "@deepseek-ai/dsh-tool-fs-search",
+	grep: "@deepseek-ai/dsh-tool-fs-search",
+	str_replace_editor: "@deepseek-ai/dsh-tool-str-replace-editor",
+	bash: "@deepseek-ai/dsh-tool-bash",
+	pwsh: "@deepseek-ai/dsh-tool-pwsh",
+	web_search: "@deepseek-ai/dsh-tool-web",
+	web_fetch: "@deepseek-ai/dsh-tool-web",
+	job_output: "@deepseek-ai/dsh-tool-jobs",
+	job_list: "@deepseek-ai/dsh-tool-jobs",
+	job_kill: "@deepseek-ai/dsh-tool-jobs",
+	ask_user_question: "@deepseek-ai/dsh-tool-ask-user",
+	plan: "@deepseek-ai/dsh-plan-mode",
+	exit_plan_mode: "@deepseek-ai/dsh-plan-mode",
+	skill: "@deepseek-ai/dsh-tool-skill",
+	todo_write: "@deepseek-ai/dsh-tool-todo",
+	subagent: "@deepseek-ai/dsh-tool-subagent",
+	subagent_fork: "@deepseek-ai/dsh-tool-subagent",
+	send_message: "@deepseek-ai/dsh-tool-subagent-control",
+	interrupt_agent: "@deepseek-ai/dsh-tool-subagent-control",
+	list_agents: "@deepseek-ai/dsh-tool-subagent-control",
+	ralph: "@deepseek-ai/dsh-tool-ralph",
+	workflow: "@deepseek-ai/dsh-tool-workflow",
+	run_code: "@deepseek-ai/dsh-tools",
+	schedule_create: "@deepseek-ai/dsh-schedule",
+	schedule_list: "@deepseek-ai/dsh-schedule",
+	schedule_delete: "@deepseek-ai/dsh-schedule",
+	create_goal: "@deepseek-ai/dsh-tool-goal",
+	get_goal: "@deepseek-ai/dsh-tool-goal",
+	update_goal: "@deepseek-ai/dsh-tool-goal",
+	lsp: "@deepseek-ai/dsh-tool-lsp"
+});
+//#endregion
+//#region src/host/attribution.ts
+/**
+* Live tool→plugin attribution layered on the static recovery in
+* toolSources.ts.
+*
+* The session log records tools as plain `ToolSchema` entries (name /
+* description / parameters) — the registering plugin is not in there.
+* toolSources.ts derives the deterministic sources (harness-logged field,
+* `mcp:<server>` naming, pinned first-party map). This module additionally
+* watches RUNTIME registrations: cordis fires the `internal/get` waterfall on
+* every context read of a service property, passing the READING context as the
+* first argument, so `reader.fiber.name` identifies the plugin that is about
+* to call `register()`.
+*
+* - The `internal/get` handler records who last read the `tools` service and
+*   wraps that instance's `register` (once — an earlier wrapper of a previous
+*   hook incarnation is peeled back to the original, so a plugin reload
+*   re-wraps without stacking) to capture the reader at registration time
+*   into a live map.
+* - When the reader slot is missing, root-named, or this plugin's own (e.g.
+*   LOCAL-LINK plugins — dev installs via `dsh plugin add <path>` or
+*   npm/pnpm link — whose anonymous entrypoints make cordis fall back to the
+*   root name), the wrapped `register` falls back to the call stack: the first
+*   frame outside this package is resolved to its nearest `package.json`
+*   `name`. That covers both npm installs (`node_modules/<pkg>`) and local
+*   links (any directory carrying a package.json), which never pass through
+*   node_modules. Frames that resolve back to this package are skipped.
+* - `ownerOf(name)` prefers the name-derived `mcp:<server>` label (it names
+*   the actual provider, where the live record would only ever name the MCP
+*   proxy client), then the LIVE record — for a post-boot registration it is
+*   the truth, even when the name collides with a pinned first-party tool —
+*   then the pinned map (the boot-time guess for tools registered before the
+*   hook), and finally tags tools that were ALREADY registered when the hook
+*   installed (the boot snapshot — third-party bundles, e.g. local links like
+*   dsh-file-claim, that applied before dsh-context) with the
+*   `UNKNOWN_TOOL_SOURCE` sentinel: their registering plugin is unknowable,
+*   and a bare gap would read as "no plugin" instead of "unknown plugin".
+*
+* Best-effort by design: a read separated from `register()` by an `await` can
+* be overwritten by another plugin's read (misattribution) and the stack
+* fallback needs a resolvable package.json — both degrade to the name/pinned
+* chain; registrations that predate the hook degrade to the unknown tag. The
+* hook costs roughly +1.4us per service-property read and is negligible on
+* the rare register path (the stack walk only runs when the reader slot is
+* unusable, and its package lookups are cached per directory).
+*/
+/** This module's own file URL — the stack walk skips its own frames. */
+const selfUrl = normalize(fileURLToPath(import.meta.url));
+/** Directory → package-name cache for the synchronous walk below. */
+const packageCache = /* @__PURE__ */ new Map();
+/**
+* Best-effort package name for a module file: walk up to the nearest
+* `package.json` carrying a `name`. Works for dependencies installed under
+* `node_modules` as well as local links whose package root is any on-disk
+* directory. The per-directory results are cached.
+* @param file - absolute path of a module file.
+*/
+function packageNameFrom(file) {
+	let dir = dirname(file);
+	for (let depth = 0; depth < 12; depth++) {
+		const cached = packageCache.get(dir);
+		if (cached !== void 0) return cached;
+		const packageFile = join(dir, "package.json");
+		if (existsSync(packageFile)) try {
+			const name = JSON.parse(readFileSync(packageFile, "utf8")).name;
+			if (typeof name === "string" && name) {
+				packageCache.set(dir, name);
+				return name;
+			}
+		} catch {}
+		const parent = dirname(dir);
+		packageCache.set(dir, void 0);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+const FRAME_POSITION = /:\d+:\d+$/;
+/** Package name of this module's own package (self-fallbacks are filtered). */
+const selfPackage = packageNameFrom(selfUrl);
+/**
+* Resolve the registering package from a stack trace: walk frames from the
+* innermost out, skipping this module's own frames and frames that resolve to
+* this package, and return the package name of the first frame that resolves
+* elsewhere. Works with both `file://` URLs and bare absolute paths
+* (transpiled modules render without a scheme), with optional `fn (...)` and
+* `async` wrappers.
+* @param stack - `Error().stack`, or undefined when no fallback is desired.
+*/
+function callerPackageFrom(stack) {
+	if (!stack) return void 0;
+	for (const raw of stack.split("\n").slice(1)) {
+		let line = raw.trim();
+		if (!line.startsWith("at ")) continue;
+		line = line.slice(3);
+		if (line.startsWith("async ")) line = line.slice(6);
+		line = line.replace(/\)\s*$/, "");
+		const position = FRAME_POSITION.exec(line);
+		if (!position) continue;
+		let target = line.slice(0, -position[0].length);
+		if (target.includes("(")) target = target.slice(target.lastIndexOf("(") + 1);
+		if (target.startsWith("file://")) try {
+			target = normalize(fileURLToPath(target));
+		} catch {
+			continue;
+		}
+		else if (!/^[A-Za-z]:[\\/]/.test(target) && !target.startsWith("/") && !target.startsWith("\\\\")) continue;
+		else target = normalize(target);
+		if (target === selfUrl) continue;
+		const name = packageNameFrom(target);
+		if (name !== void 0 && name !== selfPackage) return name;
+	}
+}
+/**
+* Install the runtime-attribution hook on a cordis app context. The hook
+* rides the calling fiber's lifetime (`ctx.on` / `ctx.get`), so it is
+* disposed with the plugin.
+* @param ctx - the context the dsh-context plugin runs in; its fiber name is
+* excluded from attributions.
+*/
+function createToolAttribution(ctx) {
+	const live = /* @__PURE__ */ new Map();
+	const wrapped = /* @__PURE__ */ new WeakSet();
+	const self = ctx.fiber.name;
+	let lastReader;
+	const wrapInstance = (tools) => {
+		if (!tools || typeof tools !== "object" || wrapped.has(tools)) return;
+		const register = tools.register;
+		if (typeof register !== "function") return;
+		wrapped.add(tools);
+		const original = register.attributedOriginal ?? register;
+		if (typeof original !== "function") return;
+		const instance = tools;
+		const wrappedRegister = function(definition) {
+			const toolName = definition?.name;
+			let owner = lastReader?.fiber.name;
+			if (!owner || owner === "root" || owner === self) owner = callerPackageFrom((/* @__PURE__ */ new Error()).stack);
+			const dispose = original.call(this, definition);
+			if (typeof toolName === "string" && owner && owner !== "root" && owner !== self && owner !== selfPackage) {
+				live.set(toolName, owner);
+				if (typeof dispose === "function") return () => {
+					try {
+						return dispose();
+					} finally {
+						live.delete(toolName);
+					}
+				};
+			}
+			return dispose;
+		};
+		wrappedRegister.attributedOriginal = original;
+		instance.register = wrappedRegister;
+	};
+	ctx.on("internal/get", (reader, name, _error, next) => {
+		if (name !== "tools") return next();
+		const tools = next();
+		lastReader = reader;
+		wrapInstance(tools);
+		return tools;
+	});
+	const toolsService = ctx.get("tools", false);
+	wrapInstance(toolsService);
+	const boot = /* @__PURE__ */ new Set();
+	try {
+		const toolEntries = toolsService?.layers?.global?.tools;
+		if (toolEntries !== void 0 && typeof toolEntries.entries === "function") for (const [name] of toolEntries.entries()) boot.add(name);
+	} catch {}
+	return { ownerOf: (name) => mcpSourceOf(name) ?? live.get(name) ?? pinnedSourceOf(name) ?? (boot.has(name) ? "<unknown-plugin>" : void 0) };
+}
+//#endregion
 //#region src/host/config.ts
 /**
 * dsh-context host configuration — the `config:` block of the `dsh-context`
@@ -322,6 +562,7 @@ const headerToolSchema = z.object({
 	name: z.string(),
 	tokens: z.number().int().nonnegative(),
 	description: z.string().optional(),
+	plugin: z.string().optional(),
 	schema: z.unknown().optional()
 }).strict();
 const contextHeadersSchema = z.object({ headers: z.array(z.object({
@@ -352,6 +593,7 @@ function recordOf(event) {
 				schema: t
 			};
 			if (typeof tool.description === "string" && tool.description !== "") entry.description = tool.description;
+			if (typeof tool.plugin === "string" && tool.plugin !== "") entry.plugin = tool.plugin;
 			return entry;
 		})
 	};
@@ -362,11 +604,20 @@ function recordOf(event) {
 * The context-headers projection unit; registered alongside the timeline unit (host/index.ts); clients read it through
 * `useProjection('contextHeaders')` and degrade to tokens-only header sections when the key is absent. Dual-contract definition (see
 * compat.ts).
+* @param resolve - best-effort tool-to-plugin attribution (see toolSources.ts); fills a missing `plugin` at view time so
+* epochs folded without attribution still render a tag when the source is known.
 */
-function createContextHeadersDefinition() {
+function createContextHeadersDefinition(resolve) {
 	const view = (state) => ({ headers: state.headers.map((h) => ({
 		...h,
-		tools: h.tools.map((t) => ({ ...t }))
+		tools: h.tools.map((t) => {
+			if (resolve === void 0 || t.plugin !== void 0) return { ...t };
+			const plugin = resolve(t.name);
+			return plugin === void 0 ? { ...t } : {
+				...t,
+				plugin
+			};
+		})
 	})) });
 	return {
 		key: "contextHeaders",
@@ -834,9 +1085,9 @@ function buildTimelineView(state, bounds) {
 	const surfaceTotal = state.sums.user + state.sums.inject + state.sums.assistant + state.sums.tool;
 	const result = {
 		ok: true,
-		model: state.model,
-		provider: state.provider,
-		contextWindow: state.contextWindow,
+		...state.model !== void 0 ? { model: state.model } : {},
+		...state.provider !== void 0 ? { provider: state.provider } : {},
+		...state.contextWindow !== void 0 ? { contextWindow: state.contextWindow } : {},
 		current: {
 			system: state.systemTokens,
 			tools: state.toolsTokens,
@@ -1063,6 +1314,9 @@ const timelineStateSchema = z.object({
 * The definition carries BOTH session-projection contracts (see compat.ts):
 * `schema`/`view` for dsh <= 0.1.0-rc.8, `stateSchema`/`wire` for
 * dsh >= 0.1.1-rc.1 — each registry reads its own fields off the same unit.
+* (The return type is the mirrored dual contract, not the installed dts
+* `ProjectionDefinition`: the 0.1.1+ registry's wired-register overload
+* demands `wire` PRESENT, which the dts's optional `wire?` fails.)
 * Without the `wire` block the 0.1.1-rc.1+ registry treats the unit as
 * host-only and never delivers `contextTimeline` to the browser (the Context
 * tab would stay on its loading screen forever).
@@ -1089,8 +1343,9 @@ function createContextTimelineDefinition(config) {
 const name = "dsh-context";
 const inject = ["sessionProjections"];
 function apply(ctx, config) {
+	const attribution = createToolAttribution(ctx);
 	ctx.sessionProjections.register(createContextTimelineDefinition(config));
-	ctx.sessionProjections.register(createContextHeadersDefinition());
+	ctx.sessionProjections.register(createContextHeadersDefinition((name) => attribution.ownerOf(name)));
 	installSettings(ctx);
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "A DeepSeek Harness plugin for context insight and management, with context dashboard and context command, for understanding how the context is made of, and how it evolves.",
   "author": "bowenliang123",
   "repository": {
@@ -52,7 +52,6 @@
       "inject": [
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-settings"
       ],
@@ -71,9 +70,9 @@
   "license": "Apache-2.0",
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": ">=0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": ">=0.1.0-rc.7",
     "@deepseek-ai/schemastery": "^3.18.1",
     "react": "^18.3.1",
     "zod": "^4.4.3"
@@ -88,10 +87,10 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/node": "^26.2.0",