@danypops/pi-lector 0.2.2 → 0.4.0

package/extension/src/lector-client.ts

@@ -1,8 +1,9 @@
 import { existsSync, statSync } from "node:fs";
-import { dirname, parse } from "node:path";
+import { dirname, extname, parse } from "node:path";
 import { createRetryingClient, type RetryingClient } from "@danypops/daemon-kit/pi-client";
 import {
 	connectLectorClient,
+	descriptorForExtension,
 	type LectorClient,
 	type OperationInputs,
 	type OperationName,
@@ -10,7 +11,7 @@ import {
 	remoteErrorIs,
 	type WorkspaceId,
 } from "@danypops/lector";
-import { nearestGitRoot } from "./nearest-workspace-root.ts";
+import { nearestGitRoot, nearestProjectRoot } from "./nearest-workspace-root.ts";
 
 /**
  * Lazily connects to a running Lector daemon and caches, per project root,
@@ -38,14 +39,26 @@ let connector: ClientConnector = () => connectLectorClient();
 const retryingClient: RetryingClient<LectorClient> = createRetryingClient(() => connector(), { label: "Lector" });
 const workspaceIdByRoot = new Map<string, WorkspaceId>();
 
+/**
+ * Fires exactly once per distinct root, the moment it's first registered in this process --
+ * never on a later call that reuses the cached workspaceId. The single choke point every
+ * resolver (workspaceForPath, workspaceForDirectory, workspaceForCodeIntelligencePath,
+ * workspaceForPathOrDirectory) funnels through, so this is genuinely "the first time any tool
+ * call resolves this workspace," not just the one cwd workspace at session start.
+ */
+let onNewWorkspace: ((root: string) => void) | undefined;
+
+export function setNewWorkspaceObserver(observer: ((root: string) => void) | undefined): void {
+	onNewWorkspace = observer;
+}
+
 export interface RetryingLectorClient {
 	call<Name extends OperationName>(operation: Name, input: OperationInputs[Name]): Promise<OperationOutputs[Name]>;
 }
 
 // Kept async even though its own body has no await: every call site across this package does
-// `await lectorClient()`, and dropping async here (just to satisfy require-await) would turn an
-// internal implementation detail into a signature change rippling through every one of them.
-// eslint-disable-next-line @typescript-eslint/require-await
+// `await lectorClient()`, and dropping async here would turn an internal implementation detail
+// into a signature change rippling through every one of them.
 export async function lectorClient(): Promise<RetryingLectorClient> {
 	return {
 		call: (operation, input) => retryingClient.call((client) => client.call(operation, input)),
@@ -64,6 +77,7 @@ async function workspaceForRoot(root: string): Promise<ResolvedWorkspace> {
 	const client = await lectorClient();
 	const { workspaceId } = await client.call("workspace.registerPath", { path: root });
 	workspaceIdByRoot.set(root, workspaceId);
+	onNewWorkspace?.(root);
 	return { workspaceId, root };
 }
 
@@ -107,9 +121,17 @@ export function workspaceForDirectory(directory: string): Promise<ResolvedWorksp
  * whose filesystem-root fallback would point a real server at scanning the
  * whole disk. Falls back to the file's own containing directory instead,
  * same bound as workspaceForDirectory.
+ *
+ * Unlike workspaceForDirectory, prefers the file's own language's root markers
+ * (tsconfig.json, go.mod, Cargo.toml, ...) over the nearest .git when both exist --
+ * a monorepo subproject's own root marker is nearer and wins, so its language server
+ * gets that subproject's rootUri instead of the whole repo's.
  */
 export function workspaceForCodeIntelligencePath(absolutePath: string): Promise<ResolvedWorkspace> {
-	return workspaceForDirectory(dirname(absolutePath));
+	const directory = dirname(absolutePath);
+	const descriptor = descriptorForExtension(extname(absolutePath));
+	const root = descriptor ? (nearestProjectRoot(directory, descriptor.rootMarkers) ?? directory) : (nearestGitRoot(directory) ?? directory);
+	return workspaceForRoot(root);
 }
 
 /**

package/extension/src/mutation-history-operations.ts

@@ -0,0 +1,34 @@
+import type { MutationHistoryEntry } from "@danypops/lector";
+import { lectorClient, withWorkspace, workspaceForPath } from "./lector-client.ts";
+import { toWorkspaceRelativePath } from "./workspace-relative-path.ts";
+
+/** Thin wrapper over Lector's mutation history: every successful edit is recorded, and any entry can be reverted -- guarded the same way every other Lector write is. */
+export interface MutationHistoryOperations {
+	list(absolutePath: string, maxResults: number): Promise<readonly MutationHistoryEntry[]>;
+	revert(absolutePath: string, entryId: string): Promise<{ path: string; newHash: string | null }>;
+}
+
+export function createMutationHistoryOperations(): MutationHistoryOperations {
+	return {
+		list(absolutePath, maxResults) {
+			return withWorkspace(
+				() => workspaceForPath(absolutePath),
+				async ({ workspaceId, root }) => {
+					const client = await lectorClient();
+					const path = toWorkspaceRelativePath(root, absolutePath);
+					const { entries } = await client.call("workspace.mutationHistory", { workspaceId, path, maxResults });
+					return entries;
+				},
+			);
+		},
+		revert(absolutePath, entryId) {
+			return withWorkspace(
+				() => workspaceForPath(absolutePath),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.revertMutation", { workspaceId, entryId });
+				},
+			);
+		},
+	};
+}

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

@@ -21,14 +21,30 @@ import { dirname, join, parse } from "node:path";
  * workspace root" error -- discovered live, in a separate session, working
  * against a completely different, unrelated repository.)
  */
-export function nearestGitRoot(startDirectory: string): string | undefined {
+function walkUpForMarkers(startDirectory: string, markers: readonly string[]): string | undefined {
 	let dir = startDirectory;
 	const fsRoot = parse(dir).root;
 	while (dir !== fsRoot) {
-		if (existsSync(join(dir, ".git"))) return dir;
+		if (markers.some((marker) => existsSync(join(dir, marker)))) return dir;
 		const parent = dirname(dir);
 		if (parent === dir) break; // defensive: dirname must be strictly ascending
 		dir = parent;
 	}
-	return existsSync(join(fsRoot, ".git")) ? fsRoot : undefined;
+	return markers.some((marker) => existsSync(join(fsRoot, marker))) ? fsRoot : undefined;
+}
+
+export function nearestGitRoot(startDirectory: string): string | undefined {
+	return walkUpForMarkers(startDirectory, [".git"]);
+}
+
+/**
+ * Same nearest-enclosing-root walk as nearestGitRoot, but also checks a language's own root
+ * markers (tsconfig.json, go.mod, Cargo.toml, ...) at each directory, nearest first -- so a
+ * monorepo subproject with its own root marker resolves to itself, not the outer repo's .git.
+ * Found via @arvoretech/pi-lsp comparison: without this, a file inside a monorepo subproject
+ * misattributes its whole project to the repo root, handing the language server the wrong
+ * rootUri (and, for TypeScript, the wrong tsconfig.json) even though a closer one exists.
+ */
+export function nearestProjectRoot(startDirectory: string, rootMarkers: readonly string[]): string | undefined {
+	return walkUpForMarkers(startDirectory, [...rootMarkers, ".git"]);
 }

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

@@ -0,0 +1,26 @@
+import type { OperationOutputs } from "@danypops/lector";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "./lector-client.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.
+ */
+export interface ReferenceBasedRenameOperations {
+	rename(fromPath: string, toPath: string, maxFiles: number, maxSymbolsPerFile: number): Promise<OperationOutputs["workspace.referenceBasedRename"]>;
+}
+
+export function createReferenceBasedRenameOperations(): ReferenceBasedRenameOperations {
+	return {
+		async rename(fromPath, toPath, maxFiles, maxSymbolsPerFile) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(fromPath),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.referenceBasedRename", { workspaceId, fromPath, toPath, maxFiles, maxSymbolsPerFile });
+				},
+			);
+		},
+	};
+}

package/extension/src/rename-operations.ts

@@ -0,0 +1,36 @@
+import type { OperationOutputs } from "@danypops/lector";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "./lector-client.ts";
+
+/**
+ * Thin wrappers over Lector's LSP-driven prepareRename/rename -- position-based (path + 1-indexed
+ * line + character), matching every other code-intelligence operation's convention. `path`
+ * resolves its own workspace per call (workspaceForCodeIntelligencePath -- spawns a real
+ * language server).
+ */
+export interface RenameOperations {
+	prepareRename(path: string, line: number, character: number): Promise<OperationOutputs["workspace.prepareRename"]>;
+	rename(path: string, line: number, character: number, newName: string): Promise<OperationOutputs["workspace.rename"]>;
+}
+
+export function createRenameOperations(): RenameOperations {
+	return {
+		async prepareRename(path, line, character) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(path),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.prepareRename", { workspaceId, path, line, character });
+				},
+			);
+		},
+		async rename(path, line, character, newName) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(path),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.rename", { workspaceId, path, line, character, newName });
+				},
+			);
+		},
+	};
+}

package/extension/src/repo-cache-list-operations.ts

@@ -0,0 +1,24 @@
+import type { CachedRepositoryPage } from "@danypops/lector";
+import { lectorClient } from "./lector-client.ts";
+
+/**
+ * Thin wrapper over repo.listCache -- no network, no cache mutation, no `directory`/
+ * workspaceForDirectory resolution (matching repo-fetch-operations.ts: this queries the
+ * daemon-wide fetch cache, not a workspace-scoped concept).
+ */
+export interface RepoCacheListOperations {
+	list(
+		filters: { text?: string; host?: string; owner?: string; repo?: string; ref?: string },
+		maxResults: number,
+		cursor?: string,
+	): Promise<CachedRepositoryPage>;
+}
+
+export function createRepoCacheListOperations(): RepoCacheListOperations {
+	return {
+		async list(filters, maxResults, cursor) {
+			const client = await lectorClient();
+			return client.call("repo.listCache", { ...filters, maxResults, cursor });
+		},
+	};
+}

package/extension/src/symbol-annotation-operations.ts

@@ -25,7 +25,7 @@ export interface SymbolAnnotationOperations {
 	get(path: string, id: string): Promise<OperationOutputs["workspace.getAnnotation"]>;
 	list(
 		path: string,
-		options?: { subtype?: string; status?: OperationInputs["workspace.listAnnotations"]["status"]; maxResults?: number },
+		options?: { subtype?: string; status?: OperationInputs["workspace.listAnnotations"]["status"]; maxResults?: number; query?: string },
 	): Promise<OperationOutputs["workspace.listAnnotations"]>;
 	refresh(
 		path: string,
@@ -37,6 +37,9 @@ export interface SymbolAnnotationOperations {
 	): Promise<OperationOutputs["workspace.refreshAnnotation"]>;
 	scrub(path: string, id: string): Promise<OperationOutputs["workspace.scrubAnnotation"]>;
 	restore(path: string, id: string): Promise<OperationOutputs["workspace.restoreAnnotation"]>;
+	contain(path: string, parentId: string, childId: string): Promise<OperationOutputs["workspace.containAnnotation"]>;
+	uncontain(path: string, parentId: string, childId: string): Promise<OperationOutputs["workspace.uncontainAnnotation"]>;
+	tree(path: string, rootId: string, maxDepth: number): Promise<OperationOutputs["workspace.annotationTree"]>;
 }
 
 export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperations {
@@ -64,7 +67,13 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 				() => workspaceForCodeIntelligencePath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
-					return client.call("workspace.listAnnotations", { workspaceId, subtype: options.subtype, status: options.status, maxResults: options.maxResults });
+					return client.call("workspace.listAnnotations", {
+						workspaceId,
+						subtype: options.subtype,
+						status: options.status,
+						maxResults: options.maxResults,
+						query: options.query,
+					});
 				},
 			);
 		},
@@ -95,5 +104,32 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 				},
 			);
 		},
+		async contain(path, parentId, childId) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(path),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.containAnnotation", { workspaceId, parentId, childId });
+				},
+			);
+		},
+		async uncontain(path, parentId, childId) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(path),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.uncontainAnnotation", { workspaceId, parentId, childId });
+				},
+			);
+		},
+		async tree(path, rootId, maxDepth) {
+			return withWorkspace(
+				() => workspaceForCodeIntelligencePath(path),
+				async ({ workspaceId }) => {
+					const client = await lectorClient();
+					return client.call("workspace.annotationTree", { workspaceId, rootId, maxDepth });
+				},
+			);
+		},
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.2.2",
+	"version": "0.4.0",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -18,8 +18,8 @@
 		"typebox": "*"
 	},
 	"dependencies": {
-		"@danypops/daemon-kit": "^0.4.0",
-		"@danypops/lector": "^0.2.0"
+		"@danypops/daemon-kit": "^0.22.1",
+		"@danypops/lector": "^0.5.0"
 	},
 	"devDependencies": {
 		"@earendil-works/pi-ai": "^0.81.1",