@lmzhen/dsh-evolution-skill-discovery 0.30.43 → 0.31.1

package/lib/main-entry.js

@@ -0,0 +1,360 @@
+import { O as buildDomainGenerationPrompt, Z as ProjectionJournal, _ as buildGenerationRequest, c as AssignmentWorker, et as DomainMapFileStore, g as ViewSnapshotStore, k as ProjectionRuntime, l as JsonAssignmentQueue, o as installDiscoveryAwareness, ot as DomainGenerationCoordinator, r as renderDomainDescription, rt as DomainPolicyStore, s as installAssignmentSidecar, t as descriptionHashOf, u as DomainAssignmentService, v as resolveGenerationPort } from "./domain-description-3MIOYgVH.js";
+import { _ as skillKeyOf, c as SkillSearchCache, d as SkillIndex, r as registerSkillSearchTool } from "./tool-CvUTwKvW.js";
+import { isAbsolute, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { authorityFrom, evolutionIoAdapter, evolutionRoot, newSkillLibrary } from "@lmzhen/dsh-evolution-core";
+//#region lib/types/description-refresh.js
+function nextMapVersion(version) {
+	const numeric = Number(version);
+	return Number.isSafeInteger(numeric) && numeric >= 0 ? String(numeric + 1) : version + ".1";
+}
+/**
+* Re-render stale domain descriptions from their definition fields.
+* @param store - domain map store.
+* @returns number of refreshed domains.
+*/
+async function refreshStaleDescriptions(store) {
+	const snapshot = await store.read();
+	const stale = snapshot.domains.filter((node) => node.descriptionStatus === "stale");
+	if (stale.length === 0) return 0;
+	const now = Date.now();
+	const domains = snapshot.domains.map((node) => node.descriptionStatus !== "stale" ? node : {
+		...node,
+		description: renderDomainDescription(node),
+		descriptionHash: descriptionHashOf(node, snapshot.domains.filter((child) => child.parentIds.includes(node.id))),
+		descriptionVersion: node.descriptionVersion + 1,
+		descriptionStatus: "fresh",
+		updatedAt: now
+	});
+	await store.commit(snapshot.mapVersion, {
+		mapVersion: nextMapVersion(snapshot.mapVersion),
+		domains,
+		edges: snapshot.edges
+	});
+	return stale.length;
+}
+//#endregion
+//#region lib/types/main-entry.js
+const name = "evolution-skill-discovery";
+const inject = [
+	"skills",
+	"workingDirectory",
+	"tools",
+	"evolutionIo",
+	"systemPrompt"
+];
+var PlatformSource = class {
+	ctx;
+	library;
+	constructor(ctx, library) {
+		this.ctx = ctx;
+		this.library = library;
+	}
+	async snapshot(query) {
+		const snapshot = await this.ctx.skills.snapshot({
+			cwd: query.cwd,
+			...query.scope === void 0 ? {} : { scope: query.scope }
+		});
+		return {
+			skills: snapshot.skills,
+			complete: snapshot.complete
+		};
+	}
+	async managedSkillKeys() {
+		return new Set((await this.library.list()).filter((summary) => summary.managed).map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+	async protectedSkillKeys() {
+		return new Set((await this.library.list()).filter((summary) => summary.protectedBy !== null || summary.protectionUnknown).map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+	async pinnedSkillKeys() {
+		return new Set((await this.library.list()).filter((summary) => summary.protectedBy === "pinned").map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+};
+function searchUnavailable() {
+	return {
+		results: [],
+		truncated: false,
+		degraded: true,
+		hint: "Skill search is unavailable without a session working directory."
+	};
+}
+/** Apply the full production discovery composition. */
+function apply(ctx, config) {
+	if (typeof config.featureEpoch !== "string" || config.featureEpoch.length === 0) throw new Error("evolution-skill-discovery: featureEpoch is required");
+	const evolutionIo = ctx.evolutionIo;
+	const io = evolutionIoAdapter(() => evolutionIo.provider());
+	const source = new PlatformSource(ctx, newSkillLibrary({
+		config: {},
+		io,
+		ctx,
+		authority: authorityFrom({ origin: "foreground" })
+	}));
+	const index = new SkillIndex(source);
+	const workingDirectory = ctx.get("workingDirectory");
+	if (workingDirectory === void 0) throw new Error("evolution-skill-discovery: workingDirectory service is required");
+	const root = evolutionRoot();
+	let mode = config.mode ?? "off";
+	let generation = void 0;
+	if (mode !== "off") generation = resolveGenerationPort({
+		mode,
+		...ctx.get("llm") === void 0 ? {} : { llm: ctx.get("llm") },
+		provider: config.generationProvider ?? "deepseek-official",
+		model: config.generationModel ?? "deepseek-flash",
+		...config.generationTimeoutMs === void 0 ? {} : { timeoutMs: config.generationTimeoutMs },
+		...config.generationMaxTokens === void 0 ? {} : { maxTokens: config.generationMaxTokens },
+		...config.generationAttempts === void 0 ? {} : { attempts: config.generationAttempts }
+	});
+	const searchCache = new SkillSearchCache();
+	let searchHealthy = true;
+	const search = {
+		async allowedSkillKeys(agent, signal) {
+			if (mode === "off" || agent === void 0) return void 0;
+			const cwd = await workingDirectory.ensure(agent, signal);
+			const view = await index.read({
+				cwd,
+				scopeKey: String(agent.id),
+				scope: agent,
+				signal
+			});
+			let snapshot;
+			try {
+				snapshot = await map.read();
+			} catch {
+				return;
+			}
+			const known = new Set(snapshot.domains.map((node) => node.id));
+			const effective = (await policyFor(cwd)).resolve(known);
+			const blocked = new Set(snapshot.edges.filter((edge) => edge.status === "active" && effective.disabled.has(edge.domainId)).map((edge) => edge.skillKey));
+			return new Set(view.rows.filter((row) => row.modelInvocable && !blocked.has(row.skillKey)).map((row) => row.skillKey));
+		},
+		async search(query, options, agent, signal) {
+			if (agent === void 0) return searchUnavailable();
+			const cwd = await workingDirectory.ensure(agent, signal);
+			const view = await index.read({
+				cwd,
+				scopeKey: String(agent.id),
+				scope: agent,
+				signal
+			});
+			const viewPolicy = mode === "off" ? void 0 : await policyFor(cwd);
+			const cached = await searchCache.get({
+				viewKey: view.viewKey,
+				viewCatalogDigest: view.viewCatalogDigest,
+				policyDigest: viewPolicy?.digest() ?? "off",
+				discoveryMode: mode
+			}, view.rows);
+			if (cached === void 0) {
+				searchHealthy = false;
+				return {
+					results: [],
+					truncated: false,
+					degraded: true,
+					hint: "Skill search index is unavailable. Use the full catalog or skill(name)."
+				};
+			}
+			searchHealthy = true;
+			const result = await cached.index.search(query, options);
+			return result.stale || cached.stale ? {
+				...result,
+				stale: true
+			} : result;
+		}
+	};
+	if (config.searchEnabled !== false) ctx.effect(() => registerSkillSearchTool(ctx, search));
+	ctx.on("evolution/skill-mutated", () => {
+		searchCache.clear();
+	});
+	if (mode === "off") return;
+	const map = new DomainMapFileStore(io, config.domainMapPath ?? join(root, "evolution", "domain-map.json"));
+	const journal = new ProjectionJournal(io, config.projectionJournalPath ?? join(root, "evolution", "projection-journal.json"));
+	const snapshots = new ViewSnapshotStore(io, config.viewSnapshotPath ?? join(root, "evolution", "view-snapshots.json"));
+	const globalPolicy = {
+		mode: mode === "shadow" ? "auto" : mode,
+		pinDomains: config.pinDomains,
+		disableDomains: config.disableDomains
+	};
+	const policy = new DomainPolicyStore({
+		global: globalPolicy,
+		...config.workspacePolicy === void 0 ? {} : { workspace: config.workspacePolicy },
+		...config.scopePolicy === void 0 ? {} : { scope: config.scopePolicy }
+	});
+	const readLayer = async (cwd, path) => {
+		if (path === void 0) return void 0;
+		try {
+			const text = await io.readText(isAbsolute(path) ? path : resolve(cwd, path));
+			return text === null ? void 0 : JSON.parse(text);
+		} catch (error) {
+			ctx.logger.warn("evolution-skill-discovery: policy layer unreadable: " + (error instanceof Error ? error.message : String(error)));
+			return;
+		}
+	};
+	const policyFor = async (cwd) => {
+		const workspace = await readLayer(cwd, config.workspacePolicyPath) ?? config.workspacePolicy;
+		const scope = await readLayer(cwd, config.scopePolicyPath) ?? config.scopePolicy;
+		return new DomainPolicyStore({
+			global: globalPolicy,
+			...workspace === void 0 ? {} : { workspace },
+			...scope === void 0 ? {} : { scope }
+		});
+	};
+	const runtime = new ProjectionRuntime({
+		skillIndexSource: source,
+		map,
+		policy,
+		policyFor,
+		journal,
+		workingDirectory,
+		featureEpoch: config.featureEpoch,
+		codecVersion: "1",
+		adapterVersion: "1",
+		projectionSchemaVersion: "1",
+		mode,
+		...config.maxCards === void 0 ? {} : { maxCards: config.maxCards },
+		...config.tokenBudget === void 0 ? {} : { tokenBudget: config.tokenBudget },
+		searchAvailable: () => searchHealthy && config.searchEnabled !== false,
+		...config.staleAfterHours === void 0 ? {} : { staleAfterHours: config.staleAfterHours },
+		...config.descriptionStaleAfterHours === void 0 ? {} : { descriptionStaleAfterHours: config.descriptionStaleAfterHours },
+		isFrozen: async (agent) => snapshots.isFrozen(String(agent.session.id), config.featureEpoch)
+	});
+	const queue = new JsonAssignmentQueue(io, config.assignmentQueuePath ?? join(root, "evolution", "assignment-queue.json"));
+	const assignment = new DomainAssignmentService(queue, map, {
+		createClassificationEnabled: config.createClassificationEnabled ?? false,
+		...config.provisionalThreshold === void 0 ? {} : { provisionalThreshold: config.provisionalThreshold },
+		now: Date.now
+	});
+	const worker = new AssignmentWorker(assignment, queue);
+	queue.load().then(() => worker.drain()).catch(() => {
+		ctx.logger.warn("evolution-skill-discovery: assignment queue load failed; queued work stays for the next start");
+	});
+	installAssignmentSidecar(ctx, assignment, { onSubmitted: () => {
+		worker.drain().catch((error) => {
+			ctx.logger.warn("evolution-skill-discovery: assignment drain failed: " + (error instanceof Error ? error.message : String(error)));
+		});
+	} });
+	ctx.on("agent/created", async ({ agent, source: start }) => {
+		try {
+			installDiscoveryAwareness(agent.ctx);
+		} catch (error) {
+			ctx.logger.warn("evolution-skill-discovery: awareness install failed: " + (error instanceof Error ? error.message : String(error)));
+		}
+		if (start !== "startup") return;
+		try {
+			const cwd = await workingDirectory.ensure(agent);
+			const view = await index.read({
+				cwd,
+				scopeKey: String(agent.id),
+				scope: agent
+			});
+			await snapshots.put({
+				sessionId: String(agent.session.id),
+				viewKey: view.viewKey,
+				cwd,
+				viewCatalogDigest: view.viewCatalogDigest,
+				mapVersion: "0",
+				configDigest: "production",
+				featureEpoch: config.featureEpoch,
+				createdAt: Date.now()
+			});
+			const refreshed = await refreshStaleDescriptions(map);
+			if (refreshed > 0) ctx.logger.info("evolution-skill-discovery: refreshed " + refreshed + " stale domain descriptions");
+		} catch (error) {
+			ctx.logger.warn("evolution-skill-discovery: initial view snapshot failed: " + (error instanceof Error ? error.message : String(error)));
+		}
+	});
+	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		const decision = await next();
+		try {
+			return await runtime.project(agent, decision, signal);
+		} catch (error) {
+			ctx.logger.warn("evolution-skill-discovery: projection failed open: " + (error instanceof Error ? error.message : String(error)));
+			return decision;
+		}
+	}, { prepend: true });
+	const coordinator = generation === void 0 ? void 0 : new DomainGenerationCoordinator(map, generation);
+	const commandRuntime = ctx.get("commands");
+	if (commandRuntime !== void 0) ctx.effect(() => commandRuntime.register({
+		name: "skill-domain",
+		description: "Generate or inspect the skill domain map.",
+		async handler({ rawInput, agent }) {
+			const [action] = rawInput.trim().split(/\s+/);
+			if (action === "status") {
+				const statusCwd = await workingDirectory.ensure(agent);
+				const view = await index.read({
+					cwd: statusCwd,
+					scopeKey: String(agent.id),
+					scope: agent
+				});
+				const rows = view.rows.slice(0, 12).map((row) => row.name + " | provider=" + row.provider + " source=" + row.source + " managed=" + String(row.managed) + " invocable=" + String(row.modelInvocable) + " protected=" + String(row.protected) + " pinned=" + String(row.pinned) + " key=" + row.skillKey + " hash=" + row.threeFieldHash);
+				const state = await runtime.inspect(agent);
+				const report = runtime.report(agent);
+				return {
+					kind: "success",
+					text: "discovery mode=" + mode + "; view=" + view.viewKey + "; phase=" + state.phase + " map=" + state.map + " search=" + state.search + " policy=" + state.policy + " last=" + report.action + (state.reasons.length === 0 ? "" : " reasons=" + state.reasons.join(",")) + "\n" + rows.join("\n")
+				};
+			}
+			if (action === "confirm") {
+				const domainId = rawInput.trim().split(/\s+/)[1];
+				if (domainId === void 0) return {
+					kind: "error",
+					text: "Usage: /skill-domain confirm <id>"
+				};
+				return await assignment.confirm(domainId) ? {
+					kind: "success",
+					text: "Confirmed domain " + domainId + "."
+				} : {
+					kind: "error",
+					text: "Unknown or non-provisional domain: " + domainId
+				};
+			}
+			if (action !== "generate") return {
+				kind: "error",
+				text: "Usage: /skill-domain status | generate | confirm <id>"
+			};
+			if (coordinator === void 0) return {
+				kind: "error",
+				text: "Generation is unavailable: no llm/generation port is mounted."
+			};
+			if (config.mapReferenceCwd === void 0) return {
+				kind: "error",
+				text: "No mapReferenceCwd configured; refusing to generate a global map from the caller view."
+			};
+			const view = await index.read({
+				cwd: config.mapReferenceCwd,
+				scopeKey: config.mapReferenceScope ?? String(agent.id),
+				scope: agent
+			});
+			const request = buildGenerationRequest({
+				mapScope: "global",
+				sourceDigest: view.viewCatalogDigest,
+				mapVersion: (await map.read()).mapVersion,
+				rows: view.rows,
+				prompt: buildDomainGenerationPrompt({
+					minDomains: 8,
+					maxDomains: 8
+				}),
+				promptVersion: "v2",
+				model: config.generationModel ?? "deepseek-flash",
+				runId: randomUUID()
+			});
+			const result = await coordinator.ensure(request);
+			return {
+				kind: "success",
+				text: "Domain map generated: " + result.domains.length + " domains, mapVersion=" + result.mapVersion
+			};
+		}
+	}));
+}
+//#endregion
+export { apply, inject, name };

package/lib/search-entry.js

@@ -0,0 +1,88 @@
+import { c as SkillSearchCache, d as SkillIndex, r as registerSkillSearchTool } from "./tool-CvUTwKvW.js";
+//#region lib/types/search-entry.js
+const name = "evolution-skill-discovery";
+const inject = [
+	"skills",
+	"workingDirectory",
+	"tools"
+];
+var PlatformSearchIndexSource = class {
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	async snapshot(query) {
+		const snapshot = await this.ctx.skills.snapshot({
+			cwd: query.cwd,
+			...query.scope === void 0 ? {} : { scope: query.scope }
+		});
+		return {
+			skills: snapshot.skills,
+			complete: snapshot.complete
+		};
+	}
+	async managedSkillKeys() {
+		return /* @__PURE__ */ new Set();
+	}
+	async protectedSkillKeys() {
+		return /* @__PURE__ */ new Set();
+	}
+	async pinnedSkillKeys() {
+		return /* @__PURE__ */ new Set();
+	}
+};
+function unavailable() {
+	return {
+		results: [],
+		truncated: false,
+		degraded: true,
+		hint: "Skill search is unavailable without a session working directory."
+	};
+}
+/**
+* Compose the search-only discovery surface.
+* @param ctx - plugin context with skills, workingDirectory, and tools.
+* @param config - search-only configuration.
+*/
+function apply(ctx, config) {
+	if (typeof config.featureEpoch !== "string" || config.featureEpoch.length === 0) throw new Error("evolution-skill-discovery: featureEpoch is required");
+	if (config.mode !== void 0 && config.mode !== "off") ctx.logger.warn("evolution-skill-discovery: mode=" + config.mode + " is temporarily search-only; domain/projection is disabled until its producer is installed");
+	if (config.searchEnabled === false) return;
+	const source = new PlatformSearchIndexSource(ctx);
+	const cache = new SkillSearchCache();
+	const index = new SkillIndex(source);
+	ctx.effect(() => registerSkillSearchTool(ctx, { async search(query, options, agent, signal) {
+		if (agent === void 0) return unavailable();
+		const workingDirectory = ctx.get("workingDirectory");
+		if (workingDirectory === void 0) return unavailable();
+		const cwd = await workingDirectory.ensure(agent, signal);
+		const view = await index.read({
+			cwd,
+			scopeKey: String(agent.id),
+			scope: agent,
+			signal
+		});
+		const cached = await cache.get({
+			viewKey: view.viewKey,
+			viewCatalogDigest: view.viewCatalogDigest,
+			policyDigest: "search-only",
+			discoveryMode: "off"
+		}, view.rows);
+		if (cached === void 0) return {
+			results: [],
+			truncated: false,
+			degraded: true,
+			hint: "Skill search index is unavailable. Use the full catalog or skill(name)."
+		};
+		const result = await cached.index.search(query, options);
+		return result.stale || cached.stale ? {
+			...result,
+			stale: true
+		} : result;
+	} }));
+	ctx.on("evolution/skill-mutated", () => {
+		cache.clear();
+	});
+}
+//#endregion
+export { apply, inject, name };