@dsh-electron/dsh-plugin-multi-root-workspace 0.1.9 → 0.1.11

package/lib/llm-message-fYORacvh.js

@@ -0,0 +1,206 @@
+import { createRequire } from "node:module";
+//#region src/compat/agent-instructions.ts
+/**
+* Compatibility adapter for upstream's instruction discovery and rendering.
+*
+* `@deepseek-ai/dsh-agent-instructions` renamed its renderer between two
+* releases this plugin supports, without changing its signature:
+*
+* ```text
+* 0.1.5-rc.2     renderWorkspaceContext(files, options)   RenderedWorkspaceContext
+* 0.1.6-alpha.1  renderAgentInstructions(files, options)  RenderedAgentInstructions
+* ```
+*
+* `discoverBaselineInstructionFiles` kept both its name and its signature.
+*
+* All coupling to that package is concentrated here so the business layer
+* (`src/instructions.ts`) only ever calls {@link renderInstructions} and
+* {@link InstructionsApi.discover}. A future rename is one edit in this file,
+* not a version check sprinkled through the provider.
+*
+* The export is picked by NAME rather than by comparing the release string:
+* a structural probe also copes with upstream keeping both names for a release,
+* or reshaping within one, which a version comparison does not.
+*
+* The package is loaded LAZILY, and its genuine ABSENCE is reported as absence
+* rather than thrown. It is an optional peer: the default DSH bundle mounts it,
+* but a minimal composition legitimately has neither it nor an agent, and in
+* that case this plugin's instruction row must simply contribute nothing. A
+* package that is present but cannot be evaluated is a different answer, and
+* one this adapter reports instead of caching as absence.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/agent-instructions
+*/
+/** Raised when the package is present but carries neither renderer name. */
+var DshInstructionApiError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DshInstructionApiError";
+	}
+};
+/** Resolution is attempted once per process; `null` records a confirmed absence. */
+let resolution;
+/**
+* Pick the renderer this release exports.
+* @param module - the loaded upstream module.
+* @returns the renderer.
+* @throws {DshInstructionApiError} when neither name is present.
+*/
+function selectRenderer(module) {
+	const render = module.renderAgentInstructions ?? module.renderWorkspaceContext;
+	if (render === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions exports neither renderAgentInstructions (0.1.6 and later) nor renderWorkspaceContext (0.1.5); the additional roots' instruction files cannot be rendered. Adapt src/compat/agent-instructions.ts to the installed release.");
+	return render;
+}
+/**
+* Adapt one loaded upstream module to {@link InstructionsApi}.
+* @param module - the loaded upstream module.
+* @returns the adapted surface.
+* @throws {DshInstructionApiError} when a function this plugin needs is absent.
+*/
+function adaptInstructionsModule(module) {
+	const discover = module.discoverBaselineInstructionFiles;
+	if (discover === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions does not export discoverBaselineInstructionFiles; adapt src/compat/agent-instructions.ts to the installed release.");
+	return {
+		discover: (options) => discover(options),
+		render: selectRenderer(module)
+	};
+}
+/**
+* Whether one package is installed at all, judged WITHOUT evaluating it.
+*
+* This is what separates "the optional peer is absent" from "the optional peer
+* is installed but its evaluation fails" (a missing transitive dependency, a
+* broken build). Only a genuine resolvability failure counts as absence: a
+* resolution that fails for another reason (an `exports` map with no `require`
+* condition, say) leaves the verdict to the `import()` below, which is the
+* authority on whether the module can actually be loaded.
+* @param specifier - the bare package specifier to probe.
+* @returns whether the package resolves from this module.
+*/
+function isPackageInstalled(specifier) {
+	try {
+		createRequire(import.meta.url).resolve(specifier);
+		return true;
+	} catch (error) {
+		const code = error?.code;
+		return code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND";
+	}
+}
+/**
+* Load and adapt the upstream instruction surface, once.
+*
+* @returns the adapted surface, or `undefined` when the package is not
+*   installed. A package that IS installed but exports neither renderer throws
+*   instead: that is a compatibility break to fix, not an optional seam. So
+*   does one that is installed but cannot be evaluated at all — a missing
+*   transitive dependency, a broken build — because reporting that as absence
+*   would drop every additional root's instructions for the rest of the
+*   process. See {@link isPackageInstalled} for how the two are told apart.
+*/
+async function instructionsApi() {
+	resolution ??= (async () => {
+		if (!isPackageInstalled("@deepseek-ai/dsh-agent-instructions")) return null;
+		return adaptInstructionsModule(await import("@deepseek-ai/dsh-agent-instructions"));
+	})();
+	return await resolution ?? void 0;
+}
+/**
+* Render loaded instruction files within a byte budget, through whichever
+* renderer the installed release exports.
+*
+* This is the only rendering entry point the business layer uses.
+* @param files - loaded files, ordered broadest to most specific.
+* @param options - the byte budget.
+* @returns the rendered text and its budget diagnostics.
+* @throws {DshInstructionApiError} when no usable renderer is installed.
+*/
+async function renderInstructions(files, options) {
+	const api = await instructionsApi();
+	if (api === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions is not installed, so instruction files cannot be rendered. Check for its presence with instructionsApi() before calling renderInstructions().");
+	return api.render(files, options);
+}
+//#endregion
+//#region src/compat/llm-message.ts
+/**
+* This plugin's own producer kind.
+*
+* Session format 4 rejects the shared `kind: 'plugin'` (`format v4 message
+* requires a producer-owned source kind`). The kind is ours, not
+* `agent-instructions`: upstream treats that kind's `changes` array as its
+* own reconciliation authority.
+*/
+const PRODUCER_SOURCE_KIND = "multi-root-workspace";
+/**
+* The first session format whose encoder refuses `kind: 'plugin'`.
+* Earlier formats declare that kind on `MessageSourceMap` and require it.
+*/
+const PRODUCER_OWNED_FORMAT = 4;
+/**
+* Which source kind the installed session format will persist.
+* @param formatVersion - `SESSION_FORMAT_VERSION`, when the session package is installed.
+* @returns `plugin` through format 3, and this plugin's own kind from format 4 on.
+*/
+function instructionSourceKind(formatVersion) {
+	return formatVersion !== void 0 && formatVersion >= PRODUCER_OWNED_FORMAT ? PRODUCER_SOURCE_KIND : "plugin";
+}
+/**
+* The installed session format, when that package is present.
+*
+* A composition that never persists a session can omit the package; format 3
+* is then the spelling that still declares `kind: 'plugin'`. Any other failure
+* is a broken install and must surface.
+* @returns the format version, or `undefined` when the package is not installed.
+*/
+async function installedFormatVersion() {
+	try {
+		const session = await import("@deepseek-ai/dsh-session");
+		return typeof session.SESSION_FORMAT_VERSION === "number" ? session.SESSION_FORMAT_VERSION : void 0;
+	} catch (error) {
+		const code = error.code;
+		if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return void 0;
+		throw error;
+	}
+}
+/**
+* Build one user-role instruction message.
+*
+* Format 3 and earlier: `{ kind: 'plugin', plugin, form: 'instructions' }`.
+* Format 4 and later: `{ kind: 'multi-root-workspace', plugin, form: 'instructions' }`.
+* @param input - the body and the plugin attribution.
+* @returns the frozen message upstream's helper produced.
+* @throws {Error} when the optional peer is absent: a step that has instruction
+*   text to deliver cannot be served without it, and staying silent would drop
+*   user-visible context instead of reporting a misconfigured composition.
+*/
+async function createInstructionMessage(input) {
+	let module;
+	try {
+		module = await import("@deepseek-ai/dsh-llm");
+	} catch (error) {
+		throw new Error(`multi-root workspace: @deepseek-ai/dsh-llm is not installed, so additional roots' instruction files cannot be delivered as messages (${error instanceof Error ? error.message : String(error)}).`);
+	}
+	const create = module.createUserMessage;
+	return create({
+		content: [{
+			type: "text",
+			text: input.text
+		}],
+		source: instructionSource(input.plugin, await installedFormatVersion())
+	});
+}
+/** The source object the installed format will persist. */
+function instructionSource(plugin, formatVersion) {
+	const kind = instructionSourceKind(formatVersion);
+	if (kind === "plugin") return {
+		kind,
+		plugin,
+		form: "instructions"
+	};
+	return {
+		kind,
+		plugin,
+		form: "instructions"
+	};
+}
+//#endregion
+export { renderInstructions as i, instructionsApi as n, isPackageInstalled as r, createInstructionMessage as t };

package/lib/metadata-DgqSdVX_.js

@@ -0,0 +1,35 @@
+import { t as RootValidationError } from "./roots-Ca_W1S9n.js";
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+//#region src/skills/metadata.ts
+/** Registry metadata only; this module never resolves or grants a directory. */
+function validAliasId(value) {
+	return typeof value === "string" && value.length <= 48 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+}
+function skillsMetadataValid(row, rows) {
+	return validAliasId(row.aliasId) && typeof row.skillsEnabled === "boolean" && rows.filter((other) => other.aliasId === row.aliasId).length === 1;
+}
+function validateAliasId(value, others) {
+	if (!validAliasId(value) || others.some((row) => row.aliasId === value)) throw new RootValidationError("invalid-alias-id", "aliasId must be unique kebab-case, between 1 and 48 characters");
+	return value;
+}
+/** Missing metadata is legacy; malformed supplied metadata is preserved and withheld. */
+function migrateRootSkills(rows) {
+	const used = new Set(rows.flatMap((row) => validAliasId(row.aliasId) ? [row.aliasId] : []));
+	const generated = /* @__PURE__ */ new Map();
+	for (const row of [...rows].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) {
+		if (row.aliasId !== void 0) continue;
+		const base = (row.alias || basename(row.path)).normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32).replace(/-$/g, "") || "root";
+		const aliasId = used.has(base) ? `${base}-${createHash("sha256").update(row.id).digest("hex").slice(0, 12)}` : base;
+		if (used.has(aliasId)) continue;
+		used.add(aliasId);
+		generated.set(row, aliasId);
+	}
+	return rows.map((row) => ({
+		...row,
+		...row.aliasId === void 0 && generated.has(row) ? { aliasId: generated.get(row) } : {},
+		...row.skillsEnabled === void 0 ? { skillsEnabled: row.readOnlyRecordedPath === void 0 && (row.aliasId === void 0 || validAliasId(row.aliasId) && rows.filter((other) => other.aliasId === row.aliasId).length === 1) } : {}
+	}));
+}
+//#endregion
+export { skillsMetadataValid as n, validateAliasId as r, migrateRootSkills as t };

package/lib/{registry-BClm6wfh.js → registry-KSsmU393.js}

@@ -1,5 +1,6 @@
 import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-B5R2K3mM.js";
 import { a as classifyStoredRoots, d as reservedRootBoundary, f as resolveRootIndex, i as canonicalRoot, m as validateRootCandidate, n as additionalRootId, r as availableRoots, s as expandRootInput, t as RootValidationError, u as removeStatusAt } from "./roots-Ca_W1S9n.js";
+import { r as validateAliasId, t as migrateRootSkills } from "./metadata-DgqSdVX_.js";
 import { createRequire } from "node:module";
 import { closeSync, fstatSync, mkdirSync, openSync, statSync } from "node:fs";
 import { randomUUID } from "node:crypto";
@@ -268,6 +269,8 @@ const persistedRoot = z.object({
 	readOnlyRecordedPath: z.string().min(1).optional(),
 	readWriteRecordedPath: z.string().min(1).optional(),
 	alias: z.string().optional(),
+	aliasId: z.unknown().optional(),
+	skillsEnabled: z.unknown().optional(),
 	addedAt: z.string().min(1)
 });
 const persistedPrimaryRoot = z.object({ roots: z.array(persistedRoot) });
@@ -469,6 +472,7 @@ var MultiRootRegistry = class extends Service {
 				id: additionalRootId(randomUUID()),
 				path: canonical,
 				access,
+				skillsEnabled: access !== "read-only",
 				...grantFields(access, canonical),
 				state: "available",
 				...alias === void 0 ? {} : { alias },
@@ -477,6 +481,7 @@ var MultiRootRegistry = class extends Service {
 				...dropGrantFields(status),
 				path: canonical,
 				access: input.access ?? status.access,
+				...input.access !== void 0 && input.access !== status.access ? { skillsEnabled: input.access !== "read-only" } : {},
 				...grantFields(input.access ?? status.access, canonical),
 				addedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				...alias === void 0 ? {} : { alias }
@@ -520,6 +525,7 @@ var MultiRootRegistry = class extends Service {
 			const next = statuses.map((status, index) => index === targetIndex ? {
 				...dropGrantFields(status),
 				access,
+				skillsEnabled: access !== "read-only",
 				...recorded === void 0 ? {} : grantFields(access, recorded)
 			} : status);
 			return await this.persist(key, next);
@@ -579,6 +585,28 @@ var MultiRootRegistry = class extends Service {
 			return await this.persist(key, next);
 		});
 	}
+	/** Change a Skill switch without changing any grant field. */
+	async setSkillsEnabled(primaryRoot, ref, skillsEnabled) {
+		if (typeof skillsEnabled !== "boolean") throw new RootValidationError("invalid-ref", "skillsEnabled must be a boolean");
+		return await this.setSkillsMetadata(primaryRoot, ref, { skillsEnabled });
+	}
+	async setAliasId(primaryRoot, ref, aliasId) {
+		return await this.setSkillsMetadata(primaryRoot, ref, { aliasId });
+	}
+	async setSkillsMetadata(primaryRoot, ref, patch) {
+		await this.ensureAuthority();
+		this.requireActive();
+		const key = canonicalRoot(primaryRoot);
+		return await this.serialize(key, async () => {
+			const statuses = this.reclassify(key);
+			const target = resolveRootIndex(statuses, ref);
+			if (patch.aliasId !== void 0) validateAliasId(patch.aliasId, statuses.filter((_row, index) => index !== target));
+			return await this.persist(key, statuses.map((row, index) => index === target ? {
+				...row,
+				...patch
+			} : row));
+		});
+	}
 	/**
 	* Move one registration within the display order.
 	* @param primaryRoot - the session workspace root the root belongs to.
@@ -705,12 +733,10 @@ var MultiRootRegistry = class extends Service {
 	*/
 	async persist(key, statuses) {
 		const table = this.requireTable();
+		const durable = persistedPrimaryRoot.parse({ roots: migrateRootSkills(statuses.map(toPersistedRoot)) });
 		if (statuses.length === 0) await table.delete(key);
-		else {
-			const durable = persistedPrimaryRoot.parse({ roots: statuses.map(toPersistedRoot) });
-			await table.put(key, durable);
-		}
-		const classified = statuses.length === 0 ? [] : classifyStoredRoots(key, statuses.map(toRegisteredRoot));
+		else await table.put(key, durable);
+		const classified = statuses.length === 0 ? [] : classifyStoredRoots(key, durable.roots.map(toRegisteredRoot));
 		this.cache.set(key, classified);
 		this.publish(key, classified);
 		return classified;
@@ -750,10 +776,22 @@ var MultiRootRegistry = class extends Service {
 	* under a shared byte budget, so a move must update the live scope immediately.
 	* Aliases and no-op moves still leave the signature unchanged.
 	*/
+	metadataPublished = /* @__PURE__ */ new Map();
 	publish(key, statuses) {
 		const withheld = statuses.filter((status) => status.state !== "available");
 		const signature = [...statuses.filter((status) => status.state === "available").map((status) => `available:${status.access}:${recordedGrantOf(status)}`), ...withheld.map((status) => `${status.state}:${status.invalidReason ?? ""}:${status.access}:${status.path}:${recordedGrantOf(status) ?? ""}`)].join("\n");
-		if ((this.published.get(key) ?? "") === signature) return;
+		const previousMetadata = this.metadataPublished.get(key);
+		const metadata = JSON.stringify(statuses.map((row) => [
+			row.id,
+			row.aliasId,
+			row.skillsEnabled,
+			row.state
+		]));
+		this.metadataPublished.set(key, metadata);
+		if ((this.published.get(key) ?? "") === signature) {
+			if (previousMetadata !== metadata && (previousMetadata !== void 0 || statuses.length > 0)) for (const listener of this.listeners) listener(key);
+			return;
+		}
 		this.published.set(key, signature);
 		const effective = statuses.flatMap((status) => {
 			const recorded = recordedGrantOf(status);
@@ -851,7 +889,17 @@ var MultiRootRegistry = class extends Service {
 		this.loggedContended = false;
 		this.cache.clear();
 		this.published.clear();
-		for (const [primaryRoot, record] of this.table.entries()) this.accept(primaryRoot, record);
+		for (const [primaryRoot, record] of this.table.entries()) await this.serialize(canonicalRoot(primaryRoot), async () => {
+			const migrated = { roots: migrateRootSkills(record.roots) };
+			let accepted = record;
+			if (JSON.stringify(migrated) !== JSON.stringify(record)) try {
+				await this.table.put(primaryRoot, migrated);
+				accepted = migrated;
+			} catch (error) {
+				this.ctx.logger.warn(`multi-root skills: metadata migration failed; Skills remain withheld: ${String(error)}`);
+			}
+			this.accept(primaryRoot, accepted);
+		});
 		this.ctx.multiRootScope.setRegistryAuthority(true);
 	}
 	/** Fail closed: empty scope, no table, contended state. */
@@ -879,6 +927,7 @@ var MultiRootRegistry = class extends Service {
 	withdrawPublished() {
 		for (const key of this.published.keys()) this.ctx.multiRootScope.setAdditionalRoots(key, []);
 		this.published.clear();
+		this.metadataPublished.clear();
 		this.cache.clear();
 	}
 	/**
@@ -966,6 +1015,8 @@ function toPersistedRoot(status) {
 		path: status.path,
 		...grant,
 		...status.alias === void 0 ? {} : { alias: status.alias },
+		...status.aliasId === void 0 ? {} : { aliasId: status.aliasId },
+		...status.skillsEnabled === void 0 ? {} : { skillsEnabled: status.skillsEnabled },
 		addedAt: status.addedAt
 	};
 }
@@ -993,6 +1044,8 @@ function toRegisteredRoot(entry) {
 		...entry.readOnlyRecordedPath === void 0 ? {} : { readOnlyRecordedPath: entry.readOnlyRecordedPath },
 		...entry.readWriteRecordedPath === void 0 ? {} : { readWriteRecordedPath: entry.readWriteRecordedPath },
 		...entry.alias === void 0 ? {} : { alias: entry.alias },
+		...entry.aliasId === void 0 ? {} : { aliasId: entry.aliasId },
+		...entry.skillsEnabled === void 0 ? {} : { skillsEnabled: entry.skillsEnabled },
 		addedAt: entry.addedAt
 	};
 }

package/lib/registry.js

@@ -1,2 +1,2 @@
-import { a as MultiRootRegistry, c as multiRootDomainSpec, i as MAX_ALIAS_LENGTH, n as DOMAIN_NAME, o as REGISTRY_CONTENDED_MESSAGE, r as MAX_ADDITIONAL_ROOTS_CEILING, s as TABLE_NAME, t as DEFAULT_MAX_ADDITIONAL_ROOTS } from "./registry-BClm6wfh.js";
+import { a as MultiRootRegistry, c as multiRootDomainSpec, i as MAX_ALIAS_LENGTH, n as DOMAIN_NAME, o as REGISTRY_CONTENDED_MESSAGE, r as MAX_ADDITIONAL_ROOTS_CEILING, s as TABLE_NAME, t as DEFAULT_MAX_ADDITIONAL_ROOTS } from "./registry-KSsmU393.js";
 export { DEFAULT_MAX_ADDITIONAL_ROOTS, DOMAIN_NAME, MAX_ADDITIONAL_ROOTS_CEILING, MAX_ALIAS_LENGTH, MultiRootRegistry, MultiRootRegistry as default, REGISTRY_CONTENDED_MESSAGE, TABLE_NAME, multiRootDomainSpec };

package/lib/{review-context-D-ohSVmA.js → review-context-AH-SXHmj.js}

@@ -1,5 +1,5 @@
 import { t as effectiveDirectory } from "./session-directory-BLOstut1.js";
-import { s as touchedPathOfToolCall } from "./instructions-CGNS3H0H.js";
+import { s as touchedPathOfToolCall } from "./instructions-MePoRigy.js";
 import { l as isCanonicallyUnder } from "./roots-Ca_W1S9n.js";
 import { createHash } from "node:crypto";
 import { resolve } from "node:path";

package/lib/review-context.js

@@ -1,2 +1,2 @@
-import { t as MultiRootReviewContext } from "./review-context-D-ohSVmA.js";
+import { t as MultiRootReviewContext } from "./review-context-AH-SXHmj.js";
 export { MultiRootReviewContext, MultiRootReviewContext as default };

package/lib/scope.js

@@ -1,5 +1,5 @@
 import { t as aroundTool } from "./tool-context-CpgIFcCB.js";
-import { r as effectiveRootAccess } from "./contract-DZ4zczDT.js";
+import { r as effectiveRootAccess } from "./contract-CStSEOcK.js";
 import { statSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
@@ -356,10 +356,14 @@ var MultiRootScopeService = class extends Service {
 	* (before acquisition, on contention or storage failure, at teardown) and
 	* `available` only once its stored records have been published. Nothing
 	* else may call it, and it never touches the root table.
+	* Only transitions notify: a failed refresh may republish `unavailable`,
+	* and notifying on that no-op would re-arm Skills clients' refresh loop.
 	* @param available - whether this process holds the registry authority.
 	*/
 	setRegistryAuthority(available) {
-		this.registryAuthority = available ? "available" : "unavailable";
+		const next = available ? "available" : "unavailable";
+		if (this.registryAuthority === next) return;
+		this.registryAuthority = next;
 		for (const listener of this.listeners) listener();
 	}
 };