@danypops/pi-lector 0.12.0 → 0.12.2

package/extension/src/nearest-workspace-root.ts

@@ -1,5 +1,6 @@
-import { existsSync } from "node:fs";
-import { dirname, join, parse } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse, relative } from "node:path";
+import picomatch from "picomatch";
 
 /**
  * The bare filesystem root is never a legitimate discovered project root, even if it happens
@@ -69,3 +70,61 @@ export function nearestGitRoot(startDirectory: string, exists: (path: string) =>
 export function nearestProjectRoot(startDirectory: string, rootMarkers: readonly string[], exists: (path: string) => boolean = existsSync): string | undefined {
 	return walkUpForMarkers(startDirectory, [...rootMarkers, ".git"], exists);
 }
+
+/** An npm/yarn/bun package.json's own "workspaces" field: either a bare glob array, or `{ packages: [...] }` (pnpm's own equivalent shape for the same field, embedded inside package.json rather than a separate pnpm-workspace.yaml). */
+interface WorkspacesManifest {
+	workspaces?: string[] | { packages?: string[] };
+}
+
+function readWorkspaceGlobs(packageJsonPath: string, readFile: (path: string) => string): string[] | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFile(packageJsonPath));
+	} catch {
+		return undefined;
+	}
+	if (typeof parsed !== "object" || parsed === null) return undefined;
+	const { workspaces } = parsed as WorkspacesManifest;
+	const globs = Array.isArray(workspaces) ? workspaces : (workspaces?.packages ?? undefined);
+	return Array.isArray(globs) ? globs.filter((entry): entry is string => typeof entry === "string") : undefined;
+}
+
+/**
+ * The nearest ancestor of a real project root (as found by nearestProjectRoot) whose own
+ * package.json declares that project as a workspace member via npm/yarn/bun's "workspaces"
+ * field -- never an arbitrary ancestor that merely happens to have its own marker file. Walks
+ * upward past ancestors with no "workspaces" field (or one that doesn't actually match this
+ * project's relative path) rather than stopping at the first package.json found, since an
+ * intermediate directory can be a plain package with no workspaces declaration of its own.
+ *
+ * Mirrors how mature language tooling handles this same monorepo shape: TypeScript's tsserver
+ * only widens a file's project scope to an ancestor "solution" tsconfig that explicitly lists
+ * the nearer project in its own `references`, and rust-analyzer treats Cargo's `[workspace]`
+ * `members` list as the authoritative multi-crate boundary rather than inferring one from
+ * directory structure. This is the same idea applied to npm/yarn/bun's own declared
+ * "workspaces" glob instead of a language-specific manifest.
+ *
+ * Returns undefined (no declared ancestor) for a plain single-package repo, or when no ancestor's
+ * "workspaces" globs actually match this project -- callers must not treat an arbitrary git root
+ * as an implicit stand-in.
+ */
+export function nearestDeclaredWorkspaceRoot(
+	projectRoot: string,
+	exists: (path: string) => boolean = existsSync,
+	readFile: (path: string) => string = (path) => readFileSync(path, "utf8"),
+): string | undefined {
+	let dir = dirname(projectRoot);
+	const fsRoot = parse(dir).root;
+	while (dir !== fsRoot) {
+		const packageJsonPath = join(dir, "package.json");
+		if (exists(packageJsonPath)) {
+			const globs = readWorkspaceGlobs(packageJsonPath, readFile);
+			const relativePath = relative(dir, projectRoot);
+			if (globs?.some((glob) => picomatch(glob)(relativePath))) return dir;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break; // defensive: dirname must be strictly ascending
+		dir = parent;
+	}
+	return undefined;
+}

package/extension/src/reference-based-rename/operations.ts

@@ -1,11 +1,19 @@
-import type { OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "../lector-client.ts";
+import { type OperationOutputs, remoteErrorIs } from "@danypops/lector";
+import { lectorClient, type ResolvedWorkspace, withWorkspace, workspaceForCodeIntelligencePath, workspaceForProjectDirectory } from "../lector-client.ts";
+import { nearestDeclaredWorkspaceRoot } from "../nearest-workspace-root.ts";
 
 /**
  * Thin wrapper over Lector's non-LSP reference-based rename: moves a file and rewrites every
  * static import/export specifier the workspace's own populated symbol graph knows references it.
  * `fromPath` resolves its own workspace (workspaceForCodeIntelligencePath -- this spawns a real
  * language server), matching every other code-intelligence operation's convention.
+ *
+ * On ReferenceBasedRenameRequiresFreshGraph (the narrow per-file project was never populated),
+ * retries once against the nearest ANCESTOR whose own package.json "workspaces" field actually
+ * declares that project as a member -- never an arbitrary ancestor. This lets a caller populate
+ * the whole declared monorepo once (workspace_cache pointed at the repo root) and still rename a
+ * file inside one of its member packages, without collapsing genuinely unrelated sibling projects
+ * that were never declared together into one workspace identity.
  */
 export interface ReferenceBasedRenameOperations {
 	rename(fromPath: string, toPath: string, maxFiles: number, maxSymbolsPerFile: number): Promise<OperationOutputs["workspace.referenceBasedRename"]>;
@@ -14,13 +22,20 @@ export interface ReferenceBasedRenameOperations {
 export function createReferenceBasedRenameOperations(): ReferenceBasedRenameOperations {
 	return {
 		async rename(fromPath, toPath, maxFiles, maxSymbolsPerFile) {
-			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(fromPath),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.referenceBasedRename", { workspaceId, fromPath, toPath, maxFiles, maxSymbolsPerFile });
-				},
-			);
+			const performRename = async ({ workspaceId }: ResolvedWorkspace) => {
+				const client = await lectorClient();
+				return client.callOnce("workspace.referenceBasedRename", { workspaceId, fromPath, toPath, maxFiles, maxSymbolsPerFile });
+			};
+
+			try {
+				return await withWorkspace(() => workspaceForCodeIntelligencePath(fromPath), performRename);
+			} catch (error) {
+				if (!remoteErrorIs(error, "ReferenceBasedRenameRequiresFreshGraph")) throw error;
+				const { root: narrowRoot } = await workspaceForCodeIntelligencePath(fromPath);
+				const declaredRoot = nearestDeclaredWorkspaceRoot(narrowRoot);
+				if (!declaredRoot) throw error;
+				return withWorkspace(() => workspaceForProjectDirectory(declaredRoot), performRename);
+			}
 		},
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.12.0",
+	"version": "0.12.2",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -19,8 +19,9 @@
 	},
 	"dependencies": {
 		"@danypops/vehicle-client": "^0.2.0",
-		"@danypops/lector": "^0.16.0",
-		"malevich-tui-components": "^0.19.0"
+		"@danypops/lector": "^0.17.0",
+		"malevich-tui-components": "^0.19.0",
+		"picomatch": "^4.0.5"
 	},
 	"devDependencies": {
 		"@danypops/pi-extension-harness": "^0.2.0",
@@ -28,6 +29,7 @@
 		"@earendil-works/pi-ai": "^0.81.1",
 		"@earendil-works/pi-coding-agent": "^0.81.1",
 		"@earendil-works/pi-tui": "^0.81.1",
+		"@types/picomatch": "^4.0.3",
 		"bun-types": "latest",
 		"typebox": "^1.3.6",
 		"typescript": "^5.7.3"