dsh-wsl-workspace 0.7.1 → 0.7.2

package/lib/index.js

@@ -434,9 +434,15 @@ const MAX_LINK_RESOLUTIONS = 32;
 /** How many parent levels above the session cwd are searched for a `.git` project marker. */
 const MAX_ANCESTOR_WALK = 64;
 /**
-* How long a completed lookup is served from cache before the next rescan.
+* How many directories one discovery layer may probe at once.
+*
+* A `readdir` over the `\\wsl.localhost\…` share measured 15.6 ms against 1.6 ms
+* for a `stat`, and a budget-sized walk is 4096 directories: probing one
+* directory at a time costs 20-30 s, which is what a turn in a large workspace
+* used to wait for. The layer stays bounded so the share is never flooded; node's
+* own filesystem thread pool is what ultimately caps the real parallelism.
 */
-const CACHE_TTL_MS = 1e4;
+const WALK_CONCURRENCY = 16;
 /** Maximum cached lookups (one entry per distinct scan root across sessions). */
 const CACHE_MAX_ENTRIES = 32;
 /**
@@ -516,7 +522,56 @@ async function nearestGitAncestor(distro, linuxDir, io) {
 	return void 0;
 }
 /**
+* Everything the walk learns from one directory, in the order the round trips
+* are worth paying for: the listing first — it also says which skill markers can
+* exist there at all — then the markers it showed.
+* @param distro - the WSL distribution name.
+* @param dir - the directory's Linux path.
+* @param depth - its depth below the scan root.
+* @param io - filesystem face.
+* @returns the directory's roots, child directories and unresolved links.
+*/
+async function probeDirectory(distro, dir, depth, io) {
+	let entries;
+	if (depth < MAX_SCAN_DEPTH) try {
+		entries = await io.readdir(joinUnc(distro, dir), { withFileTypes: true });
+	} catch {}
+	const listed = entries ?? [];
+	const allMarkers = PROJECT_SKILL_MARKERS.map(([marker]) => marker);
+	const markers = entries === void 0 ? allMarkers : allMarkers.filter((marker) => listed.some((entry) => entry.name === marker));
+	const roots = await skillRootsOfDirectory(distro, dir, io, markers);
+	const children = [];
+	const links = [];
+	for (const entry of listed) {
+		if (PRUNED_DIRECTORY_NAMES.has(entry.name)) continue;
+		if (entry.name.startsWith(".") && entry.name !== ".dsh" && entry.name !== ".agents") continue;
+		if (entry.name === ".dsh" || entry.name === ".agents") continue;
+		const childPath = posix.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			children.push([childPath, depth + 1]);
+			continue;
+		}
+		if (!entry.isSymbolicLink()) continue;
+		try {
+			const target = await io.stat(joinUnc(distro, childPath));
+			if (target.isDirectory()) children.push([childPath, depth + 1]);
+			continue;
+		} catch {}
+		links.push([childPath, depth + 1]);
+	}
+	return {
+		roots,
+		children,
+		links
+	};
+}
+/**
 * Scan a WSL workspace root for nested skill directories.
+*
+* A layer is probed concurrently but published in frontier order, so the
+* catalog never depends on which probe happened to finish first, and the budget
+* is claimed before any probe starts: concurrency must not change what is
+* visited, only how long it takes.
 * @param distro - the WSL distribution name.
 * @param linuxRoot - the workspace's absolute Linux path.
 * @param io - filesystem face.
@@ -528,41 +583,32 @@ async function discoverSkillRoots(distro, linuxRoot, io) {
 	let linksResolved = 0;
 	let frontier = [[linuxRoot, 0]];
 	while (frontier.length > 0 && roots.length < MAX_SKILL_ROOTS) {
-		const next = [];
-		const links = [];
-		for (const [dir, depth] of frontier) {
-			if (visited.size >= MAX_VISITED_DIRECTORIES) return roots;
-			if (visited.has(dir)) continue;
-			visited.add(dir);
-			if (roots.length < MAX_SKILL_ROOTS) {
-				const directoryRoots = await skillRootsOfDirectory(distro, dir, io);
-				roots.push(...directoryRoots.slice(0, MAX_SKILL_ROOTS - roots.length));
-			}
-			if (depth >= MAX_SCAN_DEPTH) continue;
-			let entries;
-			try {
-				entries = await io.readdir(joinUnc(distro, dir), { withFileTypes: true });
-			} catch {
-				continue;
-			}
-			for (const entry of entries) {
-				if (PRUNED_DIRECTORY_NAMES.has(entry.name)) continue;
-				if (entry.name.startsWith(".") && entry.name !== ".dsh" && entry.name !== ".agents") continue;
-				if (entry.name === ".dsh" || entry.name === ".agents") continue;
-				const childPath = posix.join(dir, entry.name);
-				if (entry.isDirectory()) {
-					next.push([childPath, depth + 1]);
-					continue;
-				}
-				if (!entry.isSymbolicLink()) continue;
-				try {
-					const target = await io.stat(joinUnc(distro, childPath));
-					if (target.isDirectory()) next.push([childPath, depth + 1]);
-					continue;
-				} catch {}
-				links.push([childPath, depth + 1]);
+		const layer = [];
+		for (const item of frontier) {
+			if (visited.size >= MAX_VISITED_DIRECTORIES) break;
+			if (visited.has(item[0])) continue;
+			visited.add(item[0]);
+			layer.push(item);
+		}
+		if (layer.length === 0) return roots;
+		const probes = new Array(layer.length);
+		let next = 0;
+		await Promise.all(Array.from({ length: Math.min(WALK_CONCURRENCY, layer.length) }, async () => {
+			for (let index = next; index < layer.length; index = next) {
+				next += 1;
+				const [dir, depth] = layer[index];
+				probes[index] = await probeDirectory(distro, dir, depth, io);
 			}
+		}));
+		const nextLayer = [];
+		const links = [];
+		for (const probe of probes) {
+			if (probe === void 0) continue;
+			if (roots.length < MAX_SKILL_ROOTS) roots.push(...probe.roots.slice(0, MAX_SKILL_ROOTS - roots.length));
+			nextLayer.push(...probe.children);
+			links.push(...probe.links);
 		}
+		if (visited.size >= MAX_VISITED_DIRECTORIES) return roots;
 		if (links.length > 0 && io.resolveLinks !== void 0 && linksResolved < MAX_LINK_RESOLUTIONS) {
 			const batch = links.slice(0, MAX_LINK_RESOLUTIONS - linksResolved);
 			linksResolved += batch.length;
@@ -572,33 +618,39 @@ async function discoverSkillRoots(distro, linuxRoot, io) {
 				if (real === void 0) continue;
 				try {
 					const info = await io.stat(real);
-					if (info.isDirectory()) next.push([uncToLinux(real), batch[index][1]]);
+					if (info.isDirectory()) nextLayer.push([uncToLinux(real), batch[index][1]]);
 				} catch {}
 			}
 		}
-		frontier = next;
+		frontier = nextLayer;
 	}
 	return roots;
 }
+/** The two project skill markers, with the source and rank each publishes. */
+const PROJECT_SKILL_MARKERS = [[
+	".dsh",
+	"project-dsh",
+	PROJECT_DSH_RANK
+], [
+	".agents",
+	"project-agents",
+	PROJECT_AGENTS_RANK
+]];
 /**
 * Publish the skill roots of one scanned directory (its `.dsh/skills` and
 * `.agents/skills`, each with the host's project ranks).
 * @param distro - the WSL distribution name.
 * @param linuxDir - the scanned directory's Linux path.
 * @param io - filesystem face.
+* @param markers - the markers worth probing. The walk narrows this to the ones
+*   its listing actually showed, because each probe is a round trip and a
+*   directory without a `.dsh` entry cannot hold `.dsh/skills`.
 * @returns the directory's skill roots that exist.
 */
-async function skillRootsOfDirectory(distro, linuxDir, io) {
+async function skillRootsOfDirectory(distro, linuxDir, io, markers = PROJECT_SKILL_MARKERS.map(([marker]) => marker)) {
 	const result = [];
-	for (const [marker, source, rank] of [[
-		".dsh",
-		"project-dsh",
-		PROJECT_DSH_RANK
-	], [
-		".agents",
-		"project-agents",
-		PROJECT_AGENTS_RANK
-	]]) {
+	for (const [marker, source, rank] of PROJECT_SKILL_MARKERS) {
+		if (!markers.includes(marker)) continue;
 		const path = joinUnc(distro, posix.join(linuxDir, marker, "skills"));
 		try {
 			const info = await io.stat(path);
@@ -790,9 +842,10 @@ function frontmatterBoolean(fields, key, dflt = false) {
 * The WSL workspace skill provider. Registered on the host's `ctx.skills`
 * registry; serves only lookups whose cwd is a WSL UNC workspace path.
 *
-* Completed `list()` lookups are cached per scan root for CACHE_TTL_MS so
-* repeated catalog builds over the slow 9P share do not rescan the tree;
-* `get()` always re-reads the skill file so body edits are picked up
+* Completed `list()` lookups are cached per scan root and served as-is: a lookup
+* is on the session's request path, and re-walking the tree there is what made
+* every turn in a large workspace wait for a 4096-directory scan of the 9P
+* share. `get()` always re-reads the skill file so body edits are picked up
 * immediately.
 *
 * A scan root that has been served is re-checked every REFRESH_POLL_MS: the
@@ -801,23 +854,23 @@ function frontmatterBoolean(fields, key, dflt = false) {
 * changed directory listing clears the cache and calls `control.invalidate()`,
 * which bumps the registry's revision; the catalog middleware re-collects on
 * the session's next request, so a skill added mid-session reaches the model
-* without starting a new session.
+* without starting a new session, and the cache is only ever refilled by a
+* lookup the detector has already invalidated.
 */
 var WslSkillsProvider = class {
 	name = "wsl-workspace";
 	control;
 	io;
-	now;
 	refreshMs;
 	/** Cheap polls between two full discovery walks (at least one). */
 	walkEveryPolls;
+	/** The published catalog per scan root, served until its detector drops it. */
 	cache = /* @__PURE__ */ new Map();
 	/** One change detector per served scan root, keyed like {@link cache}. */
 	detectors = /* @__PURE__ */ new Map();
-	constructor(control, io = nodeSkillIo, now = Date.now, refreshMs = REFRESH_POLL_MS, discoveryMs = DISCOVERY_POLL_MS) {
+	constructor(control, io = nodeSkillIo, refreshMs = REFRESH_POLL_MS, discoveryMs = DISCOVERY_POLL_MS) {
 		this.control = control;
 		this.io = io;
-		this.now = now;
 		this.refreshMs = refreshMs;
 		this.walkEveryPolls = Math.max(1, Math.round(discoveryMs / refreshMs));
 	}
@@ -836,10 +889,10 @@ var WslSkillsProvider = class {
 		const scanRoot = await nearestGitAncestor(unc.distro, unc.linuxPath, this.io) ?? unc.linuxPath;
 		const cacheKey = `${unc.distro}\u0000${scanRoot}`;
 		const cached = this.cache.get(cacheKey);
-		if (cached !== void 0 && cached.expiresAt > this.now()) {
+		if (cached !== void 0) {
 			this.cache.delete(cacheKey);
 			this.cache.set(cacheKey, cached);
-			return [...cached.candidates];
+			return [...cached];
 		}
 		const roots = await discoverSkillRoots(unc.distro, scanRoot, this.io);
 		const candidates = [];
@@ -871,17 +924,14 @@ var WslSkillsProvider = class {
 				});
 			}
 		}
-		this.cache.set(cacheKey, {
-			expiresAt: this.now() + CACHE_TTL_MS,
-			candidates
-		});
+		this.cache.set(cacheKey, candidates);
 		while (this.cache.size > CACHE_MAX_ENTRIES) {
 			const oldest = this.cache.keys().next().value;
 			if (oldest === void 0) break;
 			this.cache.delete(oldest);
 		}
 		this.watch(cacheKey, unc.distro, scanRoot, signature.join(""), roots);
-		return candidates;
+		return [...candidates];
 	}
 	/**
 	* Keep one scan root's catalog honest for as long as this provider is