@danypops/pi-lector 0.9.6 → 0.11.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 → 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 { lectorClient, workspaceForProjectDirectory } from "../lector-client.ts";
 
 /**
  * Fans out across explicitly-named directories only -- never the daemon's own "every registered

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

@@ -1,9 +1,9 @@
 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";
+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;
 
@@ -17,9 +17,21 @@ function formatOutcomeHeader(entry: CrossWorkspaceOutcome<unknown>, theme: Lecto
 	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}`)}`);
+	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) {

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/apply-explorer-diffs.ts

@@ -0,0 +1,45 @@
+import type { DirectoryExplorerSession } from "./directory-explorer-operations.ts";
+import type { ExplorerDiff } from "./explorer-diff.ts";
+
+function joinRelative(directory: string, name: string): string {
+	return directory === "" ? name : `${directory}/${name}`;
+}
+
+/** Applies a diff batch to `directory`, in order. Never partial-rolls-back a failure partway through -- the caller (the explorer's own :w confirmation flow) is responsible for surfacing which operations landed before an error, via each real thrown error's own message. */
+export async function applyExplorerDiffs(session: DirectoryExplorerSession, directory: string, diffs: readonly ExplorerDiff[]): Promise<void> {
+	for (const diff of diffs) {
+		switch (diff.kind) {
+			case "create":
+				if (diff.isDirectory) await session.createDirectory(joinRelative(directory, diff.name));
+				else await session.createFile(joinRelative(directory, diff.name));
+				break;
+			case "rename":
+				await session.renamePath(joinRelative(directory, diff.fromName), joinRelative(directory, diff.toName));
+				break;
+			case "delete":
+				if (diff.isDirectory) await session.deleteDirectory(joinRelative(directory, diff.name));
+				else await session.deleteFile(joinRelative(directory, diff.name));
+				break;
+			default: {
+				const exhaustive: never = diff;
+				throw new Error(`unreachable explorer diff kind: ${JSON.stringify(exhaustive)}`);
+			}
+		}
+	}
+}
+
+/** One human-readable confirmation line for a pending diff, shown before :w actually applies anything. */
+export function summarizeExplorerDiff(diff: ExplorerDiff): string {
+	switch (diff.kind) {
+		case "create":
+			return `+ ${diff.name}${diff.isDirectory ? "/" : ""}`;
+		case "rename":
+			return `${diff.fromName} -> ${diff.toName}`;
+		case "delete":
+			return `- ${diff.name}${diff.isDirectory ? "/" : ""}`;
+		default: {
+			const exhaustive: never = diff;
+			throw new Error(`unreachable explorer diff kind: ${JSON.stringify(exhaustive)}`);
+		}
+	}
+}

package/extension/src/editor/directory-explorer-operations.ts

@@ -0,0 +1,61 @@
+import type { DirectoryListing, WorkspaceId } from "@danypops/lector";
+import { lectorClient, withWorkspace, workspaceForPathOrDirectory } from "../lector-client.ts";
+
+/** Oil's own default (view_options.show_hidden = false): dotfiles/dotdirs excluded unless explicitly toggled. Toggling is deferred (v2) -- this always applies for now, matching the tool's own out-of-the-box behavior. */
+function isHidden(name: string): boolean {
+	return name.startsWith(".");
+}
+
+/**
+ * Backs the /editor no-path Oil-style explorer: one resolved workspace for the whole browsing
+ * session (navigating between directories never re-resolves a workspace, just changes which
+ * relative path is listed), plus the four mutation primitives its :w diff-and-apply step needs.
+ *
+ * deleteFile is not a thin pass-through: workspace.deleteEntry is hash-guarded and the explorer
+ * only ever has a directory *listing* (no content hash) for the line being deleted, so it reads
+ * the file's current hash immediately before deleting it -- an extra round trip, acceptable for
+ * an infrequent interactive action, not a hot path.
+ */
+export interface DirectoryExplorerSession {
+	readonly root: string;
+	readonly workspaceId: WorkspaceId;
+	listDirectory(relativePath: string): Promise<DirectoryListing>;
+	createFile(relativePath: string): Promise<void>;
+	createDirectory(relativePath: string): Promise<void>;
+	renamePath(oldRelativePath: string, newRelativePath: string): Promise<void>;
+	deleteFile(relativePath: string): Promise<void>;
+	deleteDirectory(relativePath: string): Promise<void>;
+}
+
+export function openDirectoryExplorer(absoluteDirectory: string): Promise<DirectoryExplorerSession> {
+	return withWorkspace(
+		() => workspaceForPathOrDirectory(absoluteDirectory),
+		async ({ workspaceId, root }) => {
+			const client = await lectorClient();
+			return {
+				root,
+				workspaceId,
+				listDirectory: async (relativePath: string): Promise<DirectoryListing> => {
+					const listing = await client.call("workspace.listDirectory", { workspaceId, path: relativePath });
+					return { ...listing, entries: listing.entries.filter((entry) => !isHidden(entry.name)) };
+				},
+				createFile: async (relativePath: string) => {
+					await client.callOnce("workspace.exactEdit", { workspaceId, path: relativePath, expectedHash: null, content: "" });
+				},
+				createDirectory: async (relativePath: string) => {
+					await client.callOnce("workspace.createDirectory", { workspaceId, path: relativePath });
+				},
+				renamePath: async (oldRelativePath: string, newRelativePath: string) => {
+					await client.callOnce("workspace.renamePath", { workspaceId, oldPath: oldRelativePath, newPath: newRelativePath });
+				},
+				deleteFile: async (relativePath: string) => {
+					const { hash } = await client.call("workspace.rawRead", { workspaceId, path: relativePath });
+					await client.callOnce("workspace.deleteEntry", { workspaceId, path: relativePath, expectedHash: hash });
+				},
+				deleteDirectory: async (relativePath: string) => {
+					await client.callOnce("workspace.deleteDirectory", { workspaceId, path: relativePath });
+				},
+			};
+		},
+	);
+}

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;
+		}
+	}
+}

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

@@ -0,0 +1,7 @@
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+/** Real theme, narrowed to exactly what the editor/explorer components need -- avoids depending on pi-coding-agent's full internal Theme shape. */
+export interface EditorTheme {
+	fg(color: ThemeColor, text: string): string;
+	bg(color: "selectedBg", text: string): string;
+}