@danypops/pi-lector 0.9.5 → 0.9.6

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

@@ -1,5 +1,5 @@
 import type { SymbolSearchResult, TextSearchResult, WorkspaceQueryOutcome } from "@danypops/lector";
-import { lectorClient, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, workspaceForProjectDirectory } from "./lector-client.ts";
 
 /**
  * Fans out across explicitly-named directories only -- never the daemon's own "every registered
@@ -10,34 +10,79 @@ import { lectorClient, workspaceForDirectory } from "./lector-client.ts";
  * required, same "no implicit fallback" convention as find_symbols/search_code.
  */
 export interface CrossWorkspaceSearchOperations {
-	findSymbols(query: string, directories: readonly string[], timeoutMs?: number): Promise<readonly WorkspaceQueryOutcome<SymbolSearchResult>[]>;
+	findSymbols(query: string, directories: readonly string[], timeoutMs?: number): Promise<readonly CrossWorkspaceOutcome<SymbolSearchResult>[]>;
 	searchText(
 		query: string,
 		directories: readonly string[],
 		maxMatches: number,
 		maxBytes: number,
 		timeoutMs?: number,
-	): Promise<readonly WorkspaceQueryOutcome<TextSearchResult>[]>;
+	): Promise<readonly CrossWorkspaceOutcome<TextSearchResult>[]>;
+}
+
+/**
+ * One caller-supplied directory's own outcome, labeled back by that literal directory (never
+ * just a workspaceId hash) so a caller can tell which of their own inputs a result belongs to.
+ * `collapsedWith` lists any OTHER requested directories that resolved to this same workspaceId --
+ * empty when this directory got its own distinct scope, as it should for a real monorepo
+ * subproject. A caller must be able to tell "two of my inputs turned out to be one workspace"
+ * apart from "these are genuinely two separate results" -- silently duplicating one payload
+ * under two different-looking entries is exactly the bug this exists to prevent.
+ */
+export interface CrossWorkspaceOutcome<T> {
+	readonly directory: string;
+	readonly workspaceId: string;
+	readonly collapsedWith: readonly string[];
+	readonly outcome: WorkspaceQueryOutcome<T>;
 }
 
 async function resolveWorkspaceIds(directories: readonly string[]): Promise<readonly string[]> {
-	const resolved = await Promise.all(directories.map((directory) => workspaceForDirectory(directory)));
+	const resolved = await Promise.all(directories.map((directory) => workspaceForProjectDirectory(directory)));
 	return resolved.map((r) => r.workspaceId);
 }
 
+/**
+ * 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.
+ */
+function zipOutcomes<T>(
+	directories: readonly string[],
+	workspaceIds: readonly string[],
+	outcomes: readonly WorkspaceQueryOutcome<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`,
+		);
+	}
+	return 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}"`);
+		}
+		const collapsedWith = directories.filter((_, otherIndex) => otherIndex !== index && workspaceIds[otherIndex] === workspaceId);
+		return { directory, workspaceId, collapsedWith, outcome };
+	});
+}
+
 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 results;
+			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 results;
+			return zipOutcomes(directories, workspaceIds, results);
 		},
 	};
 }

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

@@ -1,6 +1,7 @@
-import type { SymbolSearchResult, TextSearchResult, WorkspaceQueryOutcome } from "@danypops/lector";
+import type { SymbolSearchResult, TextSearchResult } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList } from "malevich-tui-components";
+import type { CrossWorkspaceOutcome } from "./cross-workspace-search-operations.ts";
 import { describeFindSymbolSources } from "./find-symbols-rendering.ts";
 import type { LectorTheme } from "./lector-tui-theme.ts";
 
@@ -12,21 +13,31 @@ export function formatCrossWorkspaceCall(args: { directories?: unknown; query?:
 	return `${theme.fg("accent", `"${query}"`)} ${theme.fg("dim", `across ${directories.length} project(s)`)}`;
 }
 
-function formatOutcomeHeader(outcome: WorkspaceQueryOutcome<unknown>, theme: LectorTheme): string {
-	if (outcome.status === "ready") return theme.fg("accent", outcome.workspaceId);
-	if (outcome.status === "loading") return `${theme.fg("warning", outcome.workspaceId)} ${theme.fg("warning", `-- still loading: ${outcome.message}`)}`;
-	return `${theme.fg("error", outcome.workspaceId)} ${theme.fg("error", `-- ${outcome.message}`)}`;
+function formatOutcomeHeader(entry: CrossWorkspaceOutcome<unknown>, theme: LectorTheme): string {
+	const { outcome } = entry;
+	const label = theme.fg("accent", entry.directory);
+	const lines: string[] = [];
+	if (outcome.status === "ready") lines.push(label);
+	else if (outcome.status === "loading") lines.push(`${label} ${theme.fg("warning", `-- still loading: ${outcome.message}`)}`);
+	else lines.push(`${label} ${theme.fg("error", `-- ${outcome.message}`)}`);
+	// Surfaced explicitly, never silently -- two distinct inputs resolving to one workspace means
+	// one of their own result payloads below is a real duplicate of the other's, not two independent answers.
+	if (entry.collapsedWith.length > 0) {
+		lines.push(theme.fg("warning", `  resolved to the same workspace as: ${entry.collapsedWith.join(", ")}`));
+	}
+	return lines.join("\n");
 }
 
 export function formatFindSymbolsAcrossProjectsResult(
-	results: readonly WorkspaceQueryOutcome<SymbolSearchResult>[] | undefined,
+	results: readonly CrossWorkspaceOutcome<SymbolSearchResult>[] | undefined,
 	expanded: boolean,
 	theme: LectorTheme,
 ): string {
 	if (!results || results.length === 0) return theme.fg("dim", "No projects to search.");
 	const lines: string[] = [];
-	for (const outcome of results) {
-		lines.push(formatOutcomeHeader(outcome, theme));
+	for (const entry of results) {
+		lines.push(formatOutcomeHeader(entry, theme));
+		const { outcome } = entry;
 		if (outcome.status !== "ready") continue;
 		lines.push(
 			theme.fg("muted", `  ${outcome.result.provenance.fidelity} via ${outcome.result.provenance.backend}${outcome.result.truncated ? " (truncated)" : ""}`),
@@ -50,14 +61,15 @@ export function formatFindSymbolsAcrossProjectsResult(
 }
 
 export function formatSearchTextAcrossProjectsResult(
-	results: readonly WorkspaceQueryOutcome<TextSearchResult>[] | undefined,
+	results: readonly CrossWorkspaceOutcome<TextSearchResult>[] | undefined,
 	expanded: boolean,
 	theme: LectorTheme,
 ): string {
 	if (!results || results.length === 0) return theme.fg("dim", "No projects to search.");
 	const lines: string[] = [];
-	for (const outcome of results) {
-		lines.push(formatOutcomeHeader(outcome, theme));
+	for (const entry of results) {
+		lines.push(formatOutcomeHeader(entry, theme));
+		const { outcome } = entry;
 		if (outcome.status !== "ready") continue;
 		if (outcome.result.matches.length === 0) {
 			lines.push(theme.fg("dim", "  no matches"));

package/extension/src/index.ts

@@ -27,7 +27,6 @@ import type {
 	WorkspaceCacheStatus,
 	WorkspaceLocation,
 	WorkspaceMapResult,
-	WorkspaceQueryOutcome,
 } from "@danypops/lector";
 import { DEFAULT_EXTERNAL_SEARCH_MAX_RESULTS, PACKAGE_ECOSYSTEMS } from "@danypops/lector";
 import {
@@ -68,7 +67,7 @@ import {
 	formatWorkspaceMapCall,
 	formatWorkspaceMapResult,
 } from "./code-intelligence-rendering.ts";
-import { createLectorCrossWorkspaceSearchOperations } from "./cross-workspace-search-operations.ts";
+import { type CrossWorkspaceOutcome, createLectorCrossWorkspaceSearchOperations } from "./cross-workspace-search-operations.ts";
 import { formatCrossWorkspaceCall, formatFindSymbolsAcrossProjectsResult, formatSearchTextAcrossProjectsResult } from "./cross-workspace-search-rendering.ts";
 import { createLectorEditOperations } from "./edit-operations.ts";
 import { createExternalSearchOperations } from "./external-search-operations.ts";
@@ -1725,7 +1724,7 @@ export default function (pi: ExtensionAPI) {
 			name: "find_symbols_across_projects",
 			label: "Find Symbols Across Projects",
 			description:
-				"Fans out a symbol-name search across several explicitly-named project directories at once (e.g. several fetched repos, or a handful of related local projects) and reports one outcome per project -- ready with real results, loading (a project's language server is still cold-starting; retry shortly), or error. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions.",
+				"Fans out a symbol-name search across several explicitly-named project directories at once (e.g. several fetched repos, or a handful of related local projects) and reports one outcome per project -- ready with real results, loading (a project's language server is still cold-starting; retry shortly), or error. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions. Each directory resolves to its OWN nearest project root (package.json/tsconfig.json/go.mod/Cargo.toml/...), not the outer repo's git root -- sibling packages under one monorepo stay distinct scopes rather than collapsing into one. A result's collapsedWith lists any other requested directories that genuinely did resolve to the same workspace; empty means it got its own.",
 			promptSnippet: "Search for a symbol name across several projects at once",
 			parameters: Type.Object({
 				directories: Type.Array(Type.String(), { description: "Project directories to search, each absolute or relative to the current working directory" }),
@@ -1751,7 +1750,7 @@ export default function (pi: ExtensionAPI) {
 						.join("\n");
 					return new Text(theme.fg("error", errorText || "find_symbols_across_projects failed"), 0, 0);
 				}
-				const details = result.details as { results?: readonly WorkspaceQueryOutcome<SymbolSearchResult>[] } | undefined;
+				const details = result.details as { results?: readonly CrossWorkspaceOutcome<SymbolSearchResult>[] } | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
 				text.setText(formatFindSymbolsAcrossProjectsResult(details?.results, expanded, theme));
 				return text;
@@ -1762,7 +1761,7 @@ export default function (pi: ExtensionAPI) {
 			name: "search_code_across_projects",
 			label: "Search Code Across Projects",
 			description:
-				"Fans out a ripgrep-backed text/regex search across several explicitly-named project directories at once and reports one outcome per project. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions.",
+				"Fans out a ripgrep-backed text/regex search across several explicitly-named project directories at once and reports one outcome per project. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions. Each directory resolves to its OWN nearest project root (package.json/tsconfig.json/go.mod/Cargo.toml/...), not the outer repo's git root -- sibling packages under one monorepo stay distinct scopes rather than collapsing into one. A result's collapsedWith lists any other requested directories that genuinely did resolve to the same workspace; empty means it got its own.",
 			promptSnippet: "Search for a pattern across several projects at once",
 			parameters: Type.Object({
 				directories: Type.Array(Type.String(), { description: "Project directories to search, each absolute or relative to the current working directory" }),
@@ -1790,7 +1789,7 @@ export default function (pi: ExtensionAPI) {
 						.join("\n");
 					return new Text(theme.fg("error", errorText || "search_code_across_projects failed"), 0, 0);
 				}
-				const details = result.details as { results?: readonly WorkspaceQueryOutcome<TextSearchResult>[] } | undefined;
+				const details = result.details as { results?: readonly CrossWorkspaceOutcome<TextSearchResult>[] } | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
 				text.setText(formatSearchTextAcrossProjectsResult(details?.results, expanded, theme));
 				return text;

package/extension/src/lector-client.ts

@@ -3,6 +3,7 @@ import { dirname, extname, parse } from "node:path";
 import {
 	connectLectorClient,
 	descriptorForExtension,
+	LANGUAGE_SERVER_DESCRIPTORS,
 	type LectorClient,
 	type OperationInputs,
 	type OperationName,
@@ -142,6 +143,30 @@ export function workspaceForCodeIntelligencePath(absolutePath: string): Promise<
 	return workspaceForRoot(root);
 }
 
+/** Every known language's own rootMarkers, deduplicated -- see workspaceForProjectDirectory. */
+const ALL_PROJECT_ROOT_MARKERS: readonly string[] = [...new Set(LANGUAGE_SERVER_DESCRIPTORS.flatMap((descriptor) => descriptor.rootMarkers))];
+
+/**
+ * Resolves a caller-supplied directory to its OWN nearest project root -- never the outer repo's
+ * git root -- so distinct sibling packages under one monorepo stay distinct workspaces. Unlike
+ * workspaceForDirectory (used by find_symbols/read/write, where one canonical workspaceId per
+ * repo is exactly the point), this is for a tool whose entire premise is comparing *different*
+ * scopes (find_symbols_across_projects, search_code_across_projects): collapsing two sibling
+ * packages into the same workspaceId there silently duplicates one package's own results under
+ * the other's name, with no error at all -- confirmed live against this monorepo
+ * (packages/lector and packages/pi-lector both resolved to the same workspaceId).
+ *
+ * Unlike workspaceForCodeIntelligencePath, there is no single file (and therefore no known
+ * extension) to pick one specific language's markers from -- a caller-supplied directory could
+ * be any language, so this checks the union of every known language's rootMarkers. Falls back to
+ * the nearest git root, then the directory itself, exactly as nearestProjectRoot already does
+ * internally (it appends ".git" to whatever marker list it's given).
+ */
+export function workspaceForProjectDirectory(directory: string): Promise<ResolvedWorkspace> {
+	const root = nearestProjectRoot(directory, ALL_PROJECT_ROOT_MARKERS) ?? directory;
+	return workspaceForRoot(root);
+}
+
 /**
  * For an operation whose `path` genuinely means "the project/workspace itself"
  * (populateSymbolGraph, workspaceMap, hasWarmIndex) rather than one specific file

package/package.json

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