@danypops/pi-lector 0.12.3 → 0.12.5

package/extension/src/cross-workspace-search/operations.ts

@@ -1,5 +1,5 @@
-import type { SymbolSearchResult, TextSearchResult, WorkspaceQueryOutcome } from "@danypops/lector";
-import { lectorClient, workspaceForProjectDirectory } from "../lector-client.ts";
+import { type SymbolSearchResult, type TextSearchResult, UnknownWorkspace, type WorkspaceQueryOutcome } from "@danypops/lector";
+import { forgetWorkspaceId, lectorClient, type ResolvedWorkspace, workspaceForProjectDirectory } from "../lector-client.ts";
 
 /**
  * Fans out across explicitly-named directories only -- never the daemon's own "every registered
@@ -36,18 +36,23 @@ export interface CrossWorkspaceOutcome<T> {
 	readonly outcome: WorkspaceQueryOutcome<T>;
 }
 
-async function resolveWorkspaceIds(directories: readonly string[]): Promise<readonly string[]> {
-	const resolved = await Promise.all(directories.map((directory) => workspaceForProjectDirectory(directory)));
-	return resolved.map((r) => r.workspaceId);
+function resolveWorkspaces(directories: readonly string[]): Promise<readonly ResolvedWorkspace[]> {
+	return Promise.all(directories.map((directory) => workspaceForProjectDirectory(directory)));
 }
 
 /**
  * Zips the daemon's own outcomes back onto the literal directories that produced them, and
- * computes collapsedWith. The daemon's search.symbols/search.text handlers map workspaceIds to
- * results 1:1, in order, with no deduplication of their own (confirmed by reading service.ts's
- * crossFindSymbols/crossSearchText: `targets.map(...)` over the exact `workspaceIds` array
- * given) -- so a length mismatch here means that contract broke, not a normal runtime condition
- * to paper over with an unsafe cast.
+ * computes collapsedWith -- by workspaceId identity, never by array position. A real, reproduced
+ * live bug: the daemon's own response order can legitimately differ from the request's
+ * workspaceIds order (an immediate per-item error for an unregistered id is reported ahead of
+ * real results, for instance) -- a caller correlating positionally then hands one directory's
+ * result to a completely different directory. Every outcome already carries its own workspaceId;
+ * this groups outcomes by that id (preserving arrival order *within* one id's own group, since
+ * two directories can legitimately share one workspaceId -- a monorepo's unmarked siblings) and
+ * consumes exactly one outcome per requested (directory, workspaceId) pair in that group, in
+ * order. A missing, duplicated-beyond-what-was-asked, or wholly unrequested workspaceId in the
+ * response means the daemon's contract broke -- fails loud rather than silently mislabeling or
+ * dropping data.
  */
 function zipOutcomes<T>(
 	directories: readonly string[],
@@ -56,33 +61,86 @@ function zipOutcomes<T>(
 ): readonly CrossWorkspaceOutcome<T>[] {
 	if (outcomes.length !== directories.length) {
 		throw new Error(
-			`Lector's search fan-out returned ${outcomes.length} outcome(s) for ${directories.length} requested directories -- expected exactly one outcome per directory, in order`,
+			`Lector's search fan-out returned ${outcomes.length} outcome(s) for ${directories.length} requested directories -- expected exactly one outcome per directory`,
 		);
 	}
-	return directories.map((directory, index) => {
+	const outcomesByWorkspaceId = new Map<string, WorkspaceQueryOutcome<T>[]>();
+	for (const outcome of outcomes) {
+		const bucket = outcomesByWorkspaceId.get(outcome.workspaceId);
+		if (bucket) bucket.push(outcome);
+		else outcomesByWorkspaceId.set(outcome.workspaceId, [outcome]);
+	}
+	const consumedByWorkspaceId = new Map<string, number>();
+	const results = directories.map((directory, index) => {
 		const workspaceId = workspaceIds[index];
-		const outcome = outcomes[index];
-		if (workspaceId === undefined || outcome === undefined) {
-			throw new Error(`Lector's search fan-out is missing a workspaceId/outcome for directory "${directory}"`);
+		if (workspaceId === undefined) throw new Error(`Lector's search fan-out is missing a resolved workspaceId for directory "${directory}"`);
+		const consumed = consumedByWorkspaceId.get(workspaceId) ?? 0;
+		const outcome = outcomesByWorkspaceId.get(workspaceId)?.[consumed];
+		if (!outcome) {
+			throw new Error(
+				`Lector's search fan-out returned no outcome for workspace "${workspaceId}" (directory "${directory}") -- the daemon's response no longer corresponds to the request`,
+			);
 		}
+		consumedByWorkspaceId.set(workspaceId, consumed + 1);
 		const collapsedWith = directories.filter((_, otherIndex) => otherIndex !== index && workspaceIds[otherIndex] === workspaceId);
 		return { directory, workspaceId, collapsedWith, outcome };
 	});
+	const totalConsumed = [...consumedByWorkspaceId.values()].reduce((sum, count) => sum + count, 0);
+	if (totalConsumed !== outcomes.length) {
+		throw new Error(
+			"Lector's search fan-out returned an outcome for a workspace nobody asked for -- the daemon's response no longer corresponds to the request",
+		);
+	}
+	return results;
+}
+
+/** True exactly for the daemon's own "this workspaceId is not registered" outcome for this request's own workspaceId -- never a string-matched guess against an unrelated error. */
+function isUnknownWorkspaceOutcome<T>(outcome: WorkspaceQueryOutcome<T>, workspaceId: string): boolean {
+	return outcome.status === "error" && outcome.message === new UnknownWorkspace(workspaceId).message;
+}
+
+/**
+ * A daemon restart wipes its in-memory workspace registry, but this process's own workspaceId
+ * cache does not know that on its own -- a cross-workspace call through a stale cached id comes
+ * back with a real, correctly-correlated "no workspace registered" outcome for that one
+ * workspace, even though the underlying directory on disk never changed. On exactly that
+ * outcome, the stale cache entries are dropped and the whole fan-out (re-resolve every
+ * directory, then re-run) retries once -- the same bounded, idempotent recovery withWorkspace
+ * already gives single-workspace operations, extended to a batch. A genuine per-workspace error
+ * unrelated to registration (an unsupported language, a real internal failure) is never retried.
+ */
+async function withCrossWorkspaceRestartRecovery<T>(
+	directories: readonly string[],
+	perform: (resolved: readonly ResolvedWorkspace[]) => Promise<readonly CrossWorkspaceOutcome<T>[]>,
+): Promise<readonly CrossWorkspaceOutcome<T>[]> {
+	const resolved = await resolveWorkspaces(directories);
+	const outcomes = await perform(resolved);
+	const stale = outcomes.filter((entry) => isUnknownWorkspaceOutcome(entry.outcome, entry.workspaceId));
+	if (stale.length === 0) return outcomes;
+	for (const entry of stale) {
+		const match = resolved.find((candidate) => candidate.workspaceId === entry.workspaceId);
+		if (match) forgetWorkspaceId(match.root);
+	}
+	return perform(await resolveWorkspaces(directories));
 }
 
 export function createLectorCrossWorkspaceSearchOperations(): CrossWorkspaceSearchOperations {
 	return {
-		async findSymbols(query, directories, timeoutMs) {
-			const workspaceIds = await resolveWorkspaceIds(directories);
-			const client = await lectorClient();
-			const { results } = await client.call("search.symbols", { query, workspaceIds, timeoutMs });
-			return zipOutcomes(directories, workspaceIds, results);
+		findSymbols(query, directories, timeoutMs) {
+			return withCrossWorkspaceRestartRecovery(directories, async (resolved) => {
+				const workspaceIds = resolved.map((r) => r.workspaceId);
+				const client = await lectorClient();
+				const { results } = await client.call("search.symbols", { query, workspaceIds, timeoutMs });
+				return zipOutcomes(directories, workspaceIds, results);
+			});
 		},
-		async searchText(query, directories, maxMatches, maxBytes, timeoutMs) {
-			const workspaceIds = await resolveWorkspaceIds(directories);
-			const client = await lectorClient();
-			const { results } = await client.call("search.text", { query, maxMatches, maxBytes, workspaceIds, timeoutMs });
-			return zipOutcomes(directories, workspaceIds, results);
+		searchText(query, directories, maxMatches, maxBytes, timeoutMs) {
+			return withCrossWorkspaceRestartRecovery(directories, async (resolved) => {
+				const workspaceIds = resolved.map((r) => r.workspaceId);
+				const client = await lectorClient();
+				const { results } = await client.call("search.text", { query, maxMatches, maxBytes, workspaceIds, timeoutMs });
+				return zipOutcomes(directories, workspaceIds, results);
+			});
 		},
 	};
 }

package/extension/src/lector-client.ts

@@ -5,13 +5,14 @@ import {
 	descriptorForExtension,
 	LANGUAGE_SERVER_DESCRIPTORS,
 	type LectorClient,
+	LectorDaemonUnavailable,
 	type OperationInputs,
 	type OperationName,
 	type OperationOutputs,
 	remoteErrorIs,
 	type WorkspaceId,
 } from "@danypops/lector";
-import { createRetryingClient, type RetryingClient } from "@danypops/vehicle-client/daemon-client";
+import { createRetryingClient, isLikelyStaleConnectionError, type RetryingClient } from "@danypops/vehicle-client/daemon-client";
 import { nearestGitRoot, nearestProjectRoot } from "./nearest-workspace-root.ts";
 
 /**
@@ -37,7 +38,10 @@ let connector: ClientConnector = () => connectLectorClient();
 // Wraps `() => connector()` rather than `connector` itself, so a test's
 // setLectorClientConnectorForTests still takes effect after this retrying
 // client is constructed once at module load.
-const retryingClient: RetryingClient<LectorClient> = createRetryingClient(() => connector(), { label: "Lector" });
+const retryingClient: RetryingClient<LectorClient> = createRetryingClient(() => connector(), {
+	label: "Lector",
+	isStaleConnectionError: (error) => error instanceof LectorDaemonUnavailable || isLikelyStaleConnectionError(error),
+});
 const workspaceIdByRoot = new Map<string, WorkspaceId>();
 
 /**
@@ -210,6 +214,16 @@ export async function withWorkspace<T>(resolve: () => Promise<ResolvedWorkspace>
 	throw new Error("Lector workspace resolution retry exhausted");
 }
 
+/**
+ * Drops one root's cached workspaceId without retrying anything itself -- the batch sibling of
+ * withWorkspace's own single-workspace `workspaceIdByRoot.delete(resolved.root)` recovery, for a
+ * caller (cross-workspace search's fan-out) that resolves many roots at once and needs to evict
+ * only the specific ones a daemon restart actually invalidated, not the whole cache.
+ */
+export function forgetWorkspaceId(root: string): void {
+	workspaceIdByRoot.delete(root);
+}
+
 export function setLectorClientConnectorForTests(value: ClientConnector): void {
 	retryingClient.reset();
 	workspaceIdByRoot.clear();

package/extension/src/workspace-cache/operations.ts

@@ -172,7 +172,7 @@ export async function monitorWorkspaceCache(operations: WorkspaceCacheOperations
 	}
 
 	let jobId: string;
-	if (initial.status === "caching") {
+	if (initial.status === "caching" || initial.status === "waiting-for-resources") {
 		jobId = initial.jobId;
 	} else {
 		options.onState({ status: "not-cached", reason: initial.reason });

package/extension/src/workspace-cache/rendering.ts

@@ -32,6 +32,7 @@ export function formatWorkspaceCacheStatusResult(status: WorkspaceCacheStatus |
 	if (!status) return theme.fg("dim", "No result.");
 	if (status.status === "not-cached") return theme.fg("warning", `not cached (${status.reason})`);
 	if (status.status === "caching") return theme.fg("accent", `caching (job ${status.jobId})`);
+	if (status.status === "waiting-for-resources") return theme.fg("accent", `waiting for resources (job ${status.jobId})`);
 	if (status.status === "partial") return theme.fg("warning", `partial -- ${formatResultCounts(status.generation.result)}`);
 	return theme.fg("success", `cached -- ${formatResultCounts(status.generation.result)}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.12.3",
+	"version": "0.12.5",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",