@danypops/pi-lector 0.9.5 → 0.10.0

package/extension/src/{apply-patch-operations.ts → apply-patch/operations.ts}

@@ -1,13 +1,13 @@
 import type { ContentHash, EditOutcome } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForPath } from "./lector-client.ts";
-import { toWorkspaceRelativePath } from "./workspace-relative-path.ts";
+import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { toWorkspaceRelativePath } from "../workspace-relative-path.ts";
 
 /**
  * Thin wrapper over workspace.applyPatch -- distinct from both the generic edit tool
  * (whole-file replace) and line_edit (per-line hash guards): applies a real unified diff's
  * hunks, guarded by one whole-file expectedHash (a patch inherently describes a
  * whole-file transformation from a known pre-image). `path` is an absolute file path, the
- * same convention edit-operations.ts and line-edit-operations.ts already use.
+ * same convention edit/operations.ts and line-edit/operations.ts already use.
  */
 export interface ApplyPatchOperations {
 	applyPatch(path: string, expectedHash: ContentHash, patchText: string): Promise<EditOutcome>;

package/extension/src/{apply-patch-rendering.ts → apply-patch/rendering.ts}

@@ -1,6 +1,6 @@
 import type { EditOutcome } from "@danypops/lector";
 import { renderDiffLines, renderTruncatedList, type TextMeasure } from "malevich-tui-components";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 /**
  * The applied result (EditOutcome) only carries a hash transition, not the

package/extension/src/{code-intelligence-operations.ts → code-intelligence/operations.ts}

@@ -1,5 +1,5 @@
 import type { JobSnapshot, OperationInputs, OperationOutputs, PopulateSymbolGraphResult, SymbolEdgeKind, SymbolNode } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath, workspaceForPathOrDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath, workspaceForPathOrDirectory } from "../lector-client.ts";
 
 /**
  * Thin wrappers over Lector's code-intelligence operations: goToDefinition,
@@ -39,7 +39,7 @@ export interface CodeIntelligenceOperations {
 	outgoingCalls(path: string, line: number, character: number): Promise<OperationOutputs["workspace.outgoingCalls"]>;
 	/**
 	 * Not exposed as a standalone Pi tool -- every workspace auto-populates on first touch via
-	 * monitorWorkspaceCache (workspace-cache-operations.ts). Kept here as an internal capability
+	 * monitorWorkspaceCache (workspace-cache/operations.ts). Kept here as an internal capability
 	 * for tests that need a populated graph. For an explicit/custom-bound population outside
 	 * Pi entirely, `lector workspace populate-symbol-graph` calls the daemon directly.
 	 */

package/extension/src/{code-intelligence-rendering.ts → code-intelligence/rendering.ts}

@@ -12,7 +12,7 @@ import type {
 } from "@danypops/lector";
 import { keyHint, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList } from "malevich-tui-components";
-import { colorForKind, formatLocation, type LectorTheme } from "./lector-tui-theme.ts";
+import { colorForKind, formatLocation, type LectorTheme } from "../lector-tui-theme.ts";
 
 /**
  * Custom TUI rendering for the code-intelligence tools: go_to_definition,

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

@@ -0,0 +1,88 @@
+import type { SymbolSearchResult, TextSearchResult, WorkspaceQueryOutcome } from "@danypops/lector";
+import { lectorClient, workspaceForProjectDirectory } from "../lector-client.ts";
+
+/**
+ * Fans out across explicitly-named directories only -- never the daemon's own "every registered
+ * workspace" default. Lector's daemon is a shared, system-wide service: leaving workspaceIds
+ * unset would search every project any other concurrent Pi session has ever registered against
+ * it, not just this session's own (confirmed live, not assumed -- a real fetched jittor workspace
+ * from an unrelated session showed up in an early test of this exact feature). `directories` is
+ * required, same "no implicit fallback" convention as find_symbols/search_code.
+ */
+export interface CrossWorkspaceSearchOperations {
+	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 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) => 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 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);
+		},
+	};
+}

package/extension/src/{cross-workspace-search-rendering.ts → cross-workspace-search/rendering.ts}

@@ -1,8 +1,9 @@
-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 { describeFindSymbolSources } from "./find-symbols-rendering.ts";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import { describeFindSymbolSources } from "../find-symbols/rendering.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
+import type { CrossWorkspaceOutcome } from "./operations.ts";
 
 const DEFAULT_VISIBLE_PER_WORKSPACE = 10;
 
@@ -12,21 +13,43 @@ 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[] = [];
+	switch (outcome.status) {
+		case "ready":
+			lines.push(label);
+			break;
+		case "loading":
+			lines.push(`${label} ${theme.fg("warning", `-- still loading: ${outcome.message}`)}`);
+			break;
+		case "error":
+			lines.push(`${label} ${theme.fg("error", `-- ${outcome.message}`)}`);
+			break;
+		default: {
+			const exhaustive: never = outcome;
+			throw new Error(`unhandled workspace query outcome status: ${JSON.stringify(exhaustive)}`);
+		}
+	}
+	// 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 +73,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/{edit-operations.ts → edit/operations.ts}

@@ -1,7 +1,7 @@
 import { type ContentHash, remoteErrorIs } from "@danypops/lector";
 import type { EditOperations } from "@earendil-works/pi-coding-agent";
-import { lectorClient, withWorkspace, workspaceForPath } from "./lector-client.ts";
-import { toWorkspaceRelativePath } from "./workspace-relative-path.ts";
+import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { toWorkspaceRelativePath } from "../workspace-relative-path.ts";
 
 /**
  * EditOperations backed by Lector's hash-guarded exactEdit. The workspace

package/extension/src/editor/editor-state.ts

@@ -0,0 +1,317 @@
+import { LiveBuffer } from "@danypops/lector";
+
+export type EditorMode = "normal" | "insert" | "command";
+
+export type EditorAction = { kind: "save" } | { kind: "save-and-quit" } | { kind: "quit" } | { kind: "hover" };
+
+const BACKSPACE_KEYS = new Set(["\x7f", "\b"]);
+
+/**
+ * Pure neovim-style modal editing state machine: mode transitions, cursor motion, and buffer
+ * edits, with no terminal/ANSI rendering and no I/O -- save/quit/hover requests surface as
+ * `pendingAction` for the hosting Component to actually perform (reading/writing through
+ * Lector's hash-guarded workspace operations lives outside this class entirely). Kept
+ * side-effect-free like this specifically so mode/motion/edit logic is unit-testable without a
+ * real terminal, per this environment's own "test behavior, not pixels" TUI-testing standard.
+ */
+export class EditorState {
+	buffer: LiveBuffer;
+	mode: EditorMode = "normal";
+	cursorLine = 1;
+	cursorCharacter = 1;
+	commandText = "";
+	pendingAction: EditorAction | undefined;
+	dirty = false;
+
+	private normalPrefix = "";
+	private insertPendingJ = false;
+	private yankedLine: string | undefined;
+
+	constructor(content: string) {
+		this.buffer = new LiveBuffer(content);
+	}
+
+	get currentLineText(): string {
+		return this.buffer.lineText(this.cursorLine);
+	}
+
+	handleKey(data: string): void {
+		this.pendingAction = undefined;
+		if (this.mode === "insert") {
+			this.handleInsertKey(data);
+		} else if (this.mode === "command") {
+			this.handleCommandKey(data);
+		} else {
+			this.handleNormalKey(data);
+		}
+		this.clampCursor();
+	}
+
+	private clampCursor(): void {
+		this.cursorLine = Math.min(Math.max(this.cursorLine, 1), this.buffer.lineCount);
+		const lineLength = this.currentLineText.length;
+		const maxCharacter = this.mode === "insert" ? lineLength + 1 : Math.max(lineLength, 1);
+		this.cursorCharacter = Math.min(Math.max(this.cursorCharacter, 1), maxCharacter);
+	}
+
+	private enterInsert(): void {
+		this.mode = "insert";
+		this.insertPendingJ = false;
+	}
+
+	// ── Normal mode ──────────────────────────────────────────────────────────
+
+	private handleNormalKey(data: string): void {
+		// Two-key sequences: dd, gg, yy.
+		if (this.normalPrefix) {
+			const prefix = this.normalPrefix;
+			this.normalPrefix = "";
+			if (prefix === "d" && data === "d") {
+				this.deleteCurrentLine();
+				return;
+			}
+			if (prefix === "g" && data === "g") {
+				this.cursorLine = 1;
+				return;
+			}
+			if (prefix === "y" && data === "y") {
+				this.yankedLine = this.currentLineText;
+				return;
+			}
+			// Prefix didn't complete into a known sequence -- fall through and handle `data` fresh.
+		}
+
+		switch (data) {
+			case "h":
+				this.cursorCharacter -= 1;
+				return;
+			case "l":
+				this.cursorCharacter += 1;
+				return;
+			case "k":
+				this.cursorLine -= 1;
+				return;
+			case "j":
+				this.cursorLine += 1;
+				return;
+			case "0":
+				this.cursorCharacter = 1;
+				return;
+			case "$":
+				this.cursorCharacter = Math.max(this.currentLineText.length, 1);
+				return;
+			case "G":
+				this.cursorLine = this.buffer.lineCount;
+				return;
+			case "d":
+			case "g":
+			case "y":
+				this.normalPrefix = data;
+				return;
+			case "i":
+				this.enterInsert();
+				return;
+			case "a":
+				this.cursorCharacter += 1;
+				this.enterInsert();
+				return;
+			case "I":
+				this.cursorCharacter = 1;
+				this.enterInsert();
+				return;
+			case "A":
+				this.cursorCharacter = this.currentLineText.length + 1;
+				this.enterInsert();
+				return;
+			case "o":
+				this.openLine(this.cursorLine);
+				return;
+			case "O":
+				this.openLine(this.cursorLine - 1);
+				return;
+			case "x":
+				this.deleteCharUnderCursor();
+				return;
+			case "p":
+				this.pasteYankedLine();
+				return;
+			case "u":
+				this.buffer.undo();
+				this.dirty = true;
+				return;
+			case "\x12": // Ctrl+R
+				this.buffer.redo();
+				this.dirty = true;
+				return;
+			case ":":
+				this.mode = "command";
+				this.commandText = "";
+				return;
+			case "\x13": // Ctrl+S
+				this.pendingAction = { kind: "save" };
+				return;
+			case "K":
+				this.pendingAction = { kind: "hover" };
+				return;
+			default:
+				return;
+		}
+	}
+
+	private openLine(afterLine: number): void {
+		const offset = this.buffer.offsetAt({ line: Math.max(afterLine, 1), character: this.buffer.lineText(Math.max(afterLine, 1)).length + 1 });
+		this.buffer.insert(offset, "\n");
+		this.cursorLine = Math.max(afterLine, 1) + 1;
+		this.cursorCharacter = 1;
+		this.enterInsert();
+		this.dirty = true;
+	}
+
+	private deleteCharUnderCursor(): void {
+		const line = this.currentLineText;
+		if (this.cursorCharacter > line.length) return;
+		const from = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.delete(from, from + 1);
+		this.dirty = true;
+	}
+
+	private deleteCurrentLine(): void {
+		const isLastLine = this.cursorLine === this.buffer.lineCount;
+		const from = this.buffer.offsetAt({ line: this.cursorLine, character: 1 });
+		const to = isLastLine
+			? this.buffer.offsetAt({ line: this.cursorLine, character: this.currentLineText.length + 1 })
+			: this.buffer.offsetAt({ line: this.cursorLine + 1, character: 1 });
+		this.yankedLine = this.currentLineText;
+		this.buffer.delete(from, to);
+		if (isLastLine && this.cursorLine > 1) this.cursorLine -= 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	private pasteYankedLine(): void {
+		if (this.yankedLine === undefined) return;
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.currentLineText.length + 1 });
+		this.buffer.insert(offset, `\n${this.yankedLine}`);
+		this.cursorLine += 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	// ── Insert mode ──────────────────────────────────────────────────────────
+
+	private handleInsertKey(data: string): void {
+		if (data === "\x1b") {
+			this.insertPendingJ = false;
+			this.mode = "normal";
+			this.cursorCharacter = Math.max(this.cursorCharacter - 1, 1);
+			return;
+		}
+
+		// "jk" chord exits insert without inserting either character -- mirrors the user's own
+		// real Neovim muscle memory (`map("i", "jk", "<ESC>")`).
+		if (this.insertPendingJ) {
+			this.insertPendingJ = false;
+			if (data === "k") {
+				this.mode = "normal";
+				return;
+			}
+			this.insertCharacter("j");
+			// Fall through and handle `data` normally (it wasn't the "k" half of the chord).
+		}
+		if (data === "j" && data.length === 1) {
+			this.insertPendingJ = true;
+			return;
+		}
+
+		if (BACKSPACE_KEYS.has(data)) {
+			this.backspace();
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.insertNewline();
+			return;
+		}
+		if (data.length === 1 && data.charCodeAt(0) >= 32) {
+			this.insertCharacter(data);
+			return;
+		}
+		// Unhandled control sequence (arrow keys, etc.) -- ignored in this v1 walking skeleton.
+	}
+
+	private insertCharacter(char: string): void {
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.insert(offset, char);
+		this.cursorCharacter += char.length;
+		this.dirty = true;
+	}
+
+	private insertNewline(): void {
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.insert(offset, "\n");
+		this.cursorLine += 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	private backspace(): void {
+		if (this.cursorCharacter > 1) {
+			const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+			this.buffer.delete(offset - 1, offset);
+			this.cursorCharacter -= 1;
+			this.dirty = true;
+			return;
+		}
+		if (this.cursorLine > 1) {
+			const previousLineLength = this.buffer.lineText(this.cursorLine - 1).length;
+			const offset = this.buffer.offsetAt({ line: this.cursorLine, character: 1 });
+			this.buffer.delete(offset - 1, offset);
+			this.cursorLine -= 1;
+			this.cursorCharacter = previousLineLength + 1;
+			this.dirty = true;
+		}
+	}
+
+	// ── Command mode ─────────────────────────────────────────────────────────
+
+	private handleCommandKey(data: string): void {
+		if (data === "\x1b") {
+			this.mode = "normal";
+			this.commandText = "";
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.executeCommand(this.commandText);
+			this.mode = "normal";
+			this.commandText = "";
+			return;
+		}
+		if (BACKSPACE_KEYS.has(data)) {
+			if (this.commandText.length === 0) {
+				this.mode = "normal";
+				return;
+			}
+			this.commandText = this.commandText.slice(0, -1);
+			return;
+		}
+		if (data.length === 1 && data.charCodeAt(0) >= 32) {
+			this.commandText += data;
+		}
+	}
+
+	private executeCommand(command: string): void {
+		switch (command) {
+			case "w":
+				this.pendingAction = { kind: "save" };
+				return;
+			case "q":
+				this.pendingAction = { kind: "quit" };
+				return;
+			case "wq":
+			case "x":
+				this.pendingAction = { kind: "save-and-quit" };
+				return;
+			default:
+				return;
+		}
+	}
+}