@liushihao456/pi-emacs 0.1.1 → 0.1.3

package/README.md

@@ -6,6 +6,8 @@ Pi extension for opening `emacsclient` from Pi's TUI.
 
 - Starts an Emacs daemon automatically when Pi starts.
 - Adds `/emacs` command.
+- Adds `/emacs:find-file` command with a file explorer for opening files or directories.
+- Adds `/emacs:project-find-file` command with a fuzzy picker over non-ignored project files from ripgrep.
 - Adds `ctrl+g` shortcut to open `emacsclient -nw` in the terminal.
 - Remembers the last file touched by Pi `edit` / `write` tools and opens it on next launch.
 - Falls back to `dired` in the current working directory when no recent file exists.
@@ -30,12 +32,17 @@ pi install /path/to/pi-emacs
 - Emacs available as `emacs`
 - Emacs client available as `emacsclient`
 - Pi interactive TUI mode
+- `@vscode/ripgrep` installed with this package for `/emacs:project-find-file`
 
 ## Usage
 
 - `/emacs` — open Emacs client
+- `/emacs:find-file` — choose a file or directory and open it in Emacs
+- `/emacs:project-find-file` — fuzzy-find a non-ignored project file and open it in Emacs
 - `ctrl+g` — open Emacs client
 
+Pi extension shortcuts currently support single key events, so Emacs-style multi-key chords such as `C-x C-f` and `C-c p f` are documented here as commands instead of registered as shortcuts.
+
 ## Publish
 
 ```bash

package/index.ts

@@ -2,27 +2,67 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { spawn } from "node:child_process";
-import { isAbsolute, resolve } from "node:path";
+import { rgPath } from "@vscode/ripgrep";
+import { readdirSync, statSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import path, { isAbsolute, resolve } from "node:path";
+import {
+	fuzzyFilter,
+	getKeybindings,
+	Input,
+	Key,
+	matchesKey,
+	truncateToWidth,
+	visibleWidth,
+	type Component,
+	type Focusable,
+} from "@earendil-works/pi-tui";
+
+type Theme = {
+	fg(color: string, text: string): string;
+};
 
 type EmacsState = {
 	startedEmacsServer: boolean;
+	serverName: string;
+	legacyDefaultServer?: boolean;
 	serverStartPromise?: Promise<void>;
+	watchdogPid?: number;
+	processShutdownHandlerVersion?: number;
 	lastEditedFile?: string;
 };
 
-const state: EmacsState = ((globalThis as any).__piEmacsExtensionState ??= {
-	startedEmacsServer: false,
-});
-
 type SpawnOptions = {
 	cwd?: string;
-	stdio?: "inherit" | "ignore";
+	stdio?: "inherit" | "ignore" | "pipe";
 	timeoutMs?: number;
 	onBefore?: () => void;
 	onAfter?: () => void;
 };
 
+type FileEntry = {
+	name: string;
+	path: string;
+	isDirectory: boolean;
+	mode: string;
+	size: string;
+	modified: Date;
+};
+
+const state: EmacsState = ((globalThis as any).__piEmacsExtensionState ??= {
+	startedEmacsServer: false,
+	serverName: `pi-emacs-${process.pid}`,
+});
+
+if (!state.serverName) {
+	state.legacyDefaultServer = state.startedEmacsServer;
+	state.serverName = `pi-emacs-${process.pid}`;
+}
+
+const FILE_EXPLORER_MAX_VISIBLE = 8;
+const PROJECT_PICKER_MAX_VISIBLE = 12;
+
 function run(command: string, args: string[], options: SpawnOptions = {}) {
 	return new Promise<void>((resolve, reject) => {
 		options.onBefore?.();
@@ -58,18 +98,189 @@ function run(command: string, args: string[], options: SpawnOptions = {}) {
 	});
 }
 
+function execText(command: string, args: string[], options: SpawnOptions = {}) {
+	return new Promise<string>((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			env: process.env,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+
+		child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+		child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			if (code === 0) {
+				resolve(Buffer.concat(stdout).toString("utf8"));
+				return;
+			}
+			reject(
+				new Error(
+					Buffer.concat(stderr).toString("utf8").trim() ||
+						`${command} exited with ${signal ?? code}`,
+				),
+			);
+		});
+	});
+}
+
+function emacsClientServerArgs(args: string[]) {
+	return ["-s", state.serverName, ...args];
+}
+
 function emacsClient(args: string[], options: SpawnOptions = {}) {
-	return run("emacsclient", args, options);
+	return run("emacsclient", emacsClientServerArgs(args), options);
+}
+
+function emacsClientSync(args: string[], timeoutMs = 5000) {
+	return spawnSync("emacsclient", emacsClientServerArgs(args), {
+		stdio: "ignore",
+		timeout: timeoutMs,
+		env: process.env,
+	});
+}
+
+function sleep(ms: number) {
+	return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
+function pidAlive(pid?: number) {
+	if (!pid) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "EPERM";
+	}
+}
+
+function emacsWatchdogScript() {
+	return `
+const { spawn, spawnSync } = require("node:child_process");
+const parentPid = Number(process.argv[1]);
+const serverName = process.argv[2];
+const startDaemon = process.argv[3] === "1";
+let stopping = false;
+let child;
+function parentAlive() {
+  try {
+    process.kill(parentPid, 0);
+    return true;
+  } catch (error) {
+    return error && error.code === "EPERM";
+  }
+}
+function killServer() {
+  spawnSync("emacsclient", ["-s", serverName, "--eval", "(kill-emacs)"], {
+    stdio: "ignore",
+    timeout: 5000,
+    env: process.env,
+  });
+}
+function stop() {
+  if (stopping) return;
+  stopping = true;
+  killServer();
+  try {
+    if (child && child.pid) process.kill(child.pid, "SIGTERM");
+  } catch {}
+  setTimeout(() => {
+    try {
+      if (child && child.pid) process.kill(child.pid, "SIGKILL");
+    } catch {}
+    process.exit(0);
+  }, 1000);
+}
+if (startDaemon) {
+  child = spawn("emacs", ["--fg-daemon=" + serverName], {
+    stdio: "ignore",
+    env: process.env,
+  });
+  child.on("error", () => process.exit(1));
+  child.on("exit", () => process.exit(0));
+}
+let ticks = 0;
+setInterval(() => {
+  if (!parentAlive()) {
+    stop();
+    return;
+  }
+  if (!startDaemon && ++ticks % 10 === 0) {
+    const result = spawnSync("emacsclient", ["-s", serverName, "--eval", "(emacs-pid)"], {
+      stdio: "ignore",
+      timeout: 1000,
+      env: process.env,
+    });
+    if (result.status !== 0) process.exit(0);
+  }
+}, 1000);
+process.on("SIGTERM", stop);
+process.on("SIGHUP", stop);
+process.on("SIGINT", stop);
+`;
+}
+
+type WatchdogMode = "start-daemon" | "watch-existing";
+
+function startEmacsWatchdog(mode: WatchdogMode) {
+	const startDaemon = mode === "start-daemon";
+	if (!startDaemon && pidAlive(state.watchdogPid)) return;
+	const watchdog = spawn(
+		process.execPath,
+		[
+			"-e",
+			emacsWatchdogScript(),
+			String(process.pid),
+			state.serverName,
+			startDaemon ? "1" : "0",
+		],
+		{
+			detached: true,
+			stdio: "ignore",
+			env: process.env,
+		},
+	);
+	state.watchdogPid = watchdog.pid;
+	watchdog.unref();
+}
+
+async function waitForEmacsServer(timeoutMs: number) {
+	const deadline = Date.now() + timeoutMs;
+	let lastError: unknown;
+	while (Date.now() < deadline) {
+		try {
+			await emacsClient(["--eval", "(emacs-pid)"], { timeoutMs: 1000 });
+			return;
+		} catch (error) {
+			lastError = error;
+			await sleep(250);
+		}
+	}
+	throw lastError instanceof Error
+		? lastError
+		: new Error("emacs daemon did not start");
+}
+
+function stopLegacyDefaultServerIfNeeded() {
+	if (!state.legacyDefaultServer) return;
+	spawnSync("emacsclient", ["--eval", "(kill-emacs)"], {
+		stdio: "ignore",
+		timeout: 5000,
+		env: process.env,
+	});
+	state.legacyDefaultServer = false;
 }
 
 function withTerminalMouse(expression: string) {
 	return `(progn (xterm-mouse-mode 1) (mouse-wheel-mode 1) ${expression})`;
 }
 
-function findFileExpression(path: string) {
+function findFileExpression(filePath: string) {
 	return withTerminalMouse(
 		[
-			`(let* ((file ${JSON.stringify(path)})`,
+			`(let* ((file ${JSON.stringify(filePath)})`,
 			"(buf (find-buffer-visiting file)))",
 			"(if buf",
 			"(progn",
@@ -86,18 +297,22 @@ function findFileExpression(path: string) {
 function diredExpression(cwd: string) {
 	return withTerminalMouse(
 		[
-			`(let* ((dir ${JSON.stringify(cwd)})`,
-			"(buf (dired-find-buffer-nocreate dir)))",
-			"(if buf",
 			"(progn",
-			"(with-current-buffer buf",
-			"(revert-buffer :ignore-auto :noconfirm))",
-			"(switch-to-buffer buf))",
-			"(dired dir)))",
+			"(mapc (lambda (b)",
+			"(when (eq (buffer-local-value 'major-mode b) 'dired-mode)",
+			"(kill-buffer b)))",
+			"(buffer-list))",
+			`(dired ${JSON.stringify(cwd)}))`,
 		].join(" "),
 	);
 }
 
+function expressionForPath(targetPath: string) {
+	return statSync(targetPath).isDirectory()
+		? diredExpression(targetPath)
+		: findFileExpression(targetPath);
+}
+
 function emacsClientArgs(cwd: string) {
 	return state.lastEditedFile
 		? ["-nw", "-a", "", "-e", findFileExpression(state.lastEditedFile)]
@@ -105,51 +320,637 @@ function emacsClientArgs(cwd: string) {
 }
 
 function rememberEditedFile(input: unknown, cwd: string) {
-	const path = (input as { path?: string }).path;
-	if (!path) return;
-	state.lastEditedFile = isAbsolute(path) ? path : resolve(cwd, path);
+	const filePath = (input as { path?: string }).path;
+	if (!filePath) return;
+	state.lastEditedFile = isAbsolute(filePath)
+		? filePath
+		: resolve(cwd, filePath);
+}
+
+function fits(width: number, text: string): string {
+	return truncateToWidth(text, Math.max(0, width), "…");
+}
+
+function indent(width: number, text: string): string {
+	return fits(width, `  ${text}`);
+}
+
+function renderInputChild(input: Input, width: number): string {
+	const line = input.render(Math.max(1, width))[0] ?? "";
+	return line.startsWith("> ") ? line.slice(2) : line;
+}
+
+function setInputValueAtEnd(input: Input, value: string): void {
+	input.setValue(value);
+	(input as unknown as { cursor: number }).cursor = value.length;
+}
+
+function dirPrefix(value: string): string {
+	const slash = value.lastIndexOf("/");
+	return slash >= 0 ? value.slice(0, slash + 1) : "";
+}
+
+function formatSize(bytes: number): string {
+	if (bytes < 1000) return `${bytes}`;
+	if (bytes < 1_000_000)
+		return `${(bytes / 1000).toFixed(bytes < 10_000 ? 1 : 0)}k`;
+	if (bytes < 1_000_000_000)
+		return `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ? 1 : 0)}M`;
+	return `${(bytes / 1_000_000_000).toFixed(1)}G`;
+}
+
+function modeString(mode: number, isDirectory: boolean): string {
+	const type = isDirectory ? "d" : "-";
+	const bits = [0o400, 0o200, 0o100, 0o040, 0o020, 0o010, 0o004, 0o002, 0o001]
+		.map((bit, index) => (mode & bit ? "rwx"[index % 3] : "-"))
+		.join("");
+	return `${type}${bits}`;
+}
+
+function relativeTime(date: Date): string {
+	const ms = Date.now() - date.getTime();
+	if (!Number.isFinite(ms) || ms < 0) return "now";
+	const sec = Math.floor(ms / 1000);
+	if (sec < 60) return "now";
+	const min = Math.floor(sec / 60);
+	if (min < 60) return `${min}m ago`;
+	const hour = Math.floor(min / 60);
+	if (hour < 24) return `${hour}h ago`;
+	const day = Math.floor(hour / 24);
+	if (day < 30) return `${day}d ago`;
+	const month = Math.floor(day / 30);
+	if (month < 12) return `${month}mo ago`;
+	return `${Math.floor(month / 12)}y ago`;
+}
+
+function normalizeExistingDir(input: string): string | null {
+	try {
+		const absolute = path.resolve(input.trim());
+		if (!statSync(absolute).isDirectory()) return null;
+		return absolute;
+	} catch {
+		return null;
+	}
+}
+
+function readFileEntries(dir: string): FileEntry[] {
+	const entries: FileEntry[] = [
+		{
+			name: "./",
+			path: dir,
+			isDirectory: true,
+			mode: "drwxr-xr-x",
+			size: "",
+			modified: new Date(),
+		},
+	];
+
+	for (const dirent of readdirSync(dir, { withFileTypes: true })) {
+		try {
+			const entryPath = path.join(dir, dirent.name);
+			const stat = statSync(entryPath);
+			const isDirectory = stat.isDirectory();
+			entries.push({
+				name: `${dirent.name}${isDirectory ? "/" : ""}`,
+				path: entryPath,
+				isDirectory,
+				mode: modeString(stat.mode, isDirectory),
+				size: formatSize(stat.size),
+				modified: stat.mtime,
+			});
+		} catch {
+			// Ignore unreadable entries.
+		}
+	}
+
+	return entries.sort((a, b) => {
+		if (a.name === "./") return -1;
+		if (b.name === "./") return 1;
+		if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+		return a.name.localeCompare(b.name);
+	});
+}
+
+class FileExplorer implements Component, Focusable {
+	private entries: FileEntry[] = [];
+	private selectedIndex = 0;
+	private readonly searchInput = new Input();
+	private error: string | undefined;
+
+	constructor(
+		initialCwd: string,
+		private readonly theme: Theme,
+		private readonly done: (path: string | null) => void,
+		private readonly requestRender: () => void,
+	) {
+		setInputValueAtEnd(
+			this.searchInput,
+			`${normalizeExistingDir(initialCwd) ?? homedir()}/`,
+		);
+		this.refresh();
+	}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+		lines.push(this.border(width));
+		lines.push(this.header(width));
+		lines.push(this.border(width, "dim"));
+		this.renderEntries(lines, width);
+		lines.push(this.border(width));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				fits(
+					width,
+					"↑↓/<C-p>/<C-n> move · <tab> enter folder · <enter> open · <M-backspace> parent · <esc> cancel",
+				),
+			),
+		);
+		return lines;
+	}
+
+	get focused(): boolean {
+		return this.searchInput.focused;
+	}
+
+	set focused(value: boolean) {
+		this.searchInput.focused = value;
+	}
+
+	invalidate(): void {
+		this.searchInput.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.escape)) {
+			this.done(null);
+			return;
+		}
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.ctrl("p"))) {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.ctrl("n"))) {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			this.enterSelectedDirectory();
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			this.chooseSelectedPath();
+			return;
+		}
+		if (getKeybindings().matches(data, "tui.editor.deleteWordBackward")) {
+			this.deletePathSegmentBackward();
+			return;
+		}
+
+		const before = this.search;
+		const beforeDir = dirPrefix(before);
+		this.searchInput.handleInput(data);
+		const after = this.search;
+		if (after !== before) {
+			if (dirPrefix(after) !== beforeDir) this.refresh();
+			else this.clampSelection();
+		}
+		this.requestRender();
+	}
+
+	private get search(): string {
+		return this.searchInput.getValue();
+	}
+
+	private set search(value: string) {
+		setInputValueAtEnd(this.searchInput, value);
+	}
+
+	private deletePathSegmentBackward(): void {
+		const before = this.search;
+		const trimmed = before.replace(/\/+$/, "");
+		const slash = trimmed.lastIndexOf("/");
+		if (slash < 0) return;
+		const next = trimmed.slice(0, slash + 1);
+		if (next === before) return;
+		this.search = next || "/";
+		this.refresh();
+		this.requestRender();
+	}
+
+	private refresh(): void {
+		try {
+			this.entries = readFileEntries(dirPrefix(this.search));
+			this.error = undefined;
+			this.selectedIndex = Math.min(1, Math.max(0, this.entries.length - 1));
+		} catch (error) {
+			this.entries = [];
+			this.selectedIndex = 0;
+			this.error = error instanceof Error ? error.message : String(error);
+		}
+	}
+
+	private header(width: number): string {
+		const entries = this.filteredEntries();
+		const total = Math.max(1, entries.length);
+		const index = Math.min(this.selectedIndex + 1, total);
+		const prefix = `${index}/${total}\tFind file: `;
+		const input = renderInputChild(
+			this.searchInput,
+			Math.max(1, width - visibleWidth(prefix)),
+		);
+		return this.theme.fg("accent", fits(width, `${prefix}${input}`));
+	}
+
+	private border(width: number, color: "accent" | "dim" = "accent"): string {
+		return this.theme.fg(color, "─".repeat(Math.max(0, width)));
+	}
+
+	private renderEntries(lines: string[], width: number): void {
+		if (this.error) {
+			lines.push(this.theme.fg("dim", indent(width, this.error)));
+			this.padRows(lines, width, 1);
+			return;
+		}
+		const entries = this.filteredEntries();
+		if (entries.length === 0) {
+			lines.push(
+				this.theme.fg(
+					"dim",
+					indent(width, this.search ? "No matches." : "No entries."),
+				),
+			);
+			this.padRows(lines, width, 1);
+			return;
+		}
+
+		let rendered = 0;
+		const start = this.visibleStart(entries.length);
+		const end = Math.min(entries.length, start + FILE_EXPLORER_MAX_VISIBLE);
+		for (let i = start; i < end; i++) {
+			lines.push(
+				this.entryLine(width, entries[i]!, {
+					selected: i === this.selectedIndex,
+				}),
+			);
+			rendered++;
+		}
+		this.padRows(lines, width, rendered);
+	}
+
+	private entryLine(
+		width: number,
+		entry: FileEntry,
+		options: { selected: boolean },
+	): string {
+		if (entry.name === "./") return this.currentDirLine(width, options);
+		const left = `${options.selected ? "›" : " "} ${entry.name}`;
+		const meta = `${entry.mode}  ${entry.size.padStart(5)}  ${relativeTime(entry.modified)}`;
+		const metaWidth = Math.min(38, Math.max(0, Math.floor(width * 0.48)));
+		const renderedMeta = fits(metaWidth, meta);
+		const renderedLeft = fits(
+			Math.max(0, width - visibleWidth(renderedMeta) - 1),
+			left,
+		);
+		const gap = " ".repeat(
+			Math.max(
+				1,
+				width - visibleWidth(renderedLeft) - visibleWidth(renderedMeta),
+			),
+		);
+		const styledLeft = options.selected
+			? this.theme.fg("accent", renderedLeft)
+			: renderedLeft;
+		return `${styledLeft}${gap}${this.theme.fg("dim", renderedMeta)}`;
+	}
+
+	private currentDirLine(
+		width: number,
+		options: { selected: boolean },
+	): string {
+		const marker = options.selected ? "›" : " ";
+		const name = `${marker} ./`;
+		const note = " (open current dir)";
+		const availableNoteWidth = Math.max(0, width - visibleWidth(name));
+		const renderedNote = fits(availableNoteWidth, note);
+		const renderedName = fits(
+			Math.max(0, width - visibleWidth(renderedNote)),
+			name,
+		);
+		const padding = " ".repeat(
+			Math.max(
+				0,
+				width - visibleWidth(renderedName) - visibleWidth(renderedNote),
+			),
+		);
+		const styledName = options.selected
+			? this.theme.fg("accent", renderedName)
+			: renderedName;
+		return `${styledName}${this.theme.fg("dim", renderedNote)}${padding}`;
+	}
+
+	private visibleStart(total: number): number {
+		if (total <= FILE_EXPLORER_MAX_VISIBLE) return 0;
+		const half = Math.floor(FILE_EXPLORER_MAX_VISIBLE / 2);
+		return Math.min(
+			Math.max(0, this.selectedIndex - half),
+			total - FILE_EXPLORER_MAX_VISIBLE,
+		);
+	}
+
+	private padRows(lines: string[], width: number, rendered: number): void {
+		for (let i = rendered; i < FILE_EXPLORER_MAX_VISIBLE; i++) {
+			lines.push(" ".repeat(Math.max(0, width)));
+		}
+	}
+
+	private filteredEntries(): FileEntry[] {
+		const query = this.search.trim().split("/").pop() ?? "";
+		if (!query) return this.entries;
+		return fuzzyFilter(this.entries, query, (entry) => entry.name);
+	}
+
+	private clampSelection(): void {
+		const maxIndex = Math.max(0, this.filteredEntries().length - 1);
+		this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, maxIndex));
+	}
+
+	private move(delta: number): void {
+		const entries = this.filteredEntries();
+		if (entries.length === 0) return;
+		this.selectedIndex =
+			(this.selectedIndex + delta + entries.length) % entries.length;
+		this.requestRender();
+	}
+
+	private selected(): FileEntry | undefined {
+		return this.filteredEntries()[this.selectedIndex];
+	}
+
+	private enterSelectedDirectory(): void {
+		const entry = this.selected();
+		if (!entry?.isDirectory) return;
+		const next = `${normalizeExistingDir(entry.path)}/`;
+		if (!next) return;
+		this.search = next;
+		this.refresh();
+		this.requestRender();
+	}
+
+	private chooseSelectedPath(): void {
+		const entry = this.selected();
+		if (entry) this.done(entry.path);
+	}
+}
+
+class ProjectFilePicker implements Component, Focusable {
+	private selectedIndex = 0;
+	private readonly searchInput = new Input();
+
+	constructor(
+		private readonly cwd: string,
+		private readonly files: string[],
+		private readonly theme: Theme,
+		private readonly done: (path: string | null) => void,
+		private readonly requestRender: () => void,
+	) {}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+		const filtered = this.filteredFiles();
+		lines.push(this.border(width));
+		lines.push(this.header(width, filtered.length));
+		lines.push(this.border(width, "dim"));
+		this.renderFiles(lines, width, filtered);
+		lines.push(this.border(width));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				fits(width, "↑↓/<C-p>/<C-n> move · <enter> open · <esc> cancel"),
+			),
+		);
+		return lines;
+	}
+
+	get focused(): boolean {
+		return this.searchInput.focused;
+	}
+
+	set focused(value: boolean) {
+		this.searchInput.focused = value;
+	}
+
+	invalidate(): void {
+		this.searchInput.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.escape)) {
+			this.done(null);
+			return;
+		}
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.ctrl("p"))) {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.ctrl("n"))) {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			this.chooseSelectedFile();
+			return;
+		}
+
+		const before = this.searchInput.getValue();
+		this.searchInput.handleInput(data);
+		if (this.searchInput.getValue() !== before) this.clampSelection();
+		this.requestRender();
+	}
+
+	private header(width: number, count: number): string {
+		const total = Math.max(1, count);
+		const index = Math.min(this.selectedIndex + 1, total);
+		const prefix = `${index}/${total}\tProject file: `;
+		const input = renderInputChild(
+			this.searchInput,
+			Math.max(1, width - visibleWidth(prefix)),
+		);
+		return this.theme.fg("accent", fits(width, `${prefix}${input}`));
+	}
+
+	private border(width: number, color: "accent" | "dim" = "accent"): string {
+		return this.theme.fg(color, "─".repeat(Math.max(0, width)));
+	}
+
+	private renderFiles(lines: string[], width: number, files: string[]): void {
+		if (files.length === 0) {
+			lines.push(this.theme.fg("dim", indent(width, "No matches.")));
+			this.padRows(lines, width, 1);
+			return;
+		}
+
+		let rendered = 0;
+		const start = this.visibleStart(files.length);
+		const end = Math.min(files.length, start + PROJECT_PICKER_MAX_VISIBLE);
+		for (let i = start; i < end; i++) {
+			const marker = i === this.selectedIndex ? "›" : " ";
+			const line = fits(width, `${marker} ${files[i]}`);
+			lines.push(
+				i === this.selectedIndex ? this.theme.fg("accent", line) : line,
+			);
+			rendered++;
+		}
+		this.padRows(lines, width, rendered);
+	}
+
+	private padRows(lines: string[], width: number, rendered: number): void {
+		for (let i = rendered; i < PROJECT_PICKER_MAX_VISIBLE; i++) {
+			lines.push(" ".repeat(Math.max(0, width)));
+		}
+	}
+
+	private filteredFiles(): string[] {
+		const query = this.searchInput.getValue().trim();
+		return query ? fuzzyFilter(this.files, query, (file) => file) : this.files;
+	}
+
+	private visibleStart(total: number): number {
+		if (total <= PROJECT_PICKER_MAX_VISIBLE) return 0;
+		const half = Math.floor(PROJECT_PICKER_MAX_VISIBLE / 2);
+		return Math.min(
+			Math.max(0, this.selectedIndex - half),
+			total - PROJECT_PICKER_MAX_VISIBLE,
+		);
+	}
+
+	private clampSelection(): void {
+		const maxIndex = Math.max(0, this.filteredFiles().length - 1);
+		this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, maxIndex));
+	}
+
+	private move(delta: number): void {
+		const files = this.filteredFiles();
+		if (files.length === 0) return;
+		this.selectedIndex =
+			(this.selectedIndex + delta + files.length) % files.length;
+		this.requestRender();
+	}
+
+	private chooseSelectedFile(): void {
+		const file = this.filteredFiles()[this.selectedIndex];
+		if (file) this.done(path.join(this.cwd, file));
+	}
+}
+
+async function projectFiles(cwd: string): Promise<string[]> {
+	const output = await execText(
+		rgPath,
+		["--files", "--hidden", "--glob", "!.git/**"],
+		{ cwd },
+	);
+	return output
+		.split(/\r?\n/)
+		.map((file) => file.trim())
+		.filter(Boolean)
+		.sort((a, b) => a.localeCompare(b));
+}
+
+async function choosePath(ctx: ExtensionContext): Promise<string | null> {
+	if (!ctx.hasUI) return null;
+	return (
+		(await ctx.ui.custom<string | null>((tui, theme, _keybindings, done) => {
+			return new FileExplorer(ctx.cwd, theme as Theme, done, () =>
+				tui.requestRender(),
+			);
+		})) ?? null
+	);
+}
+
+async function chooseProjectFile(
+	ctx: ExtensionContext,
+): Promise<string | null> {
+	if (!ctx.hasUI) return null;
+	const files = await projectFiles(ctx.cwd);
+	return (
+		(await ctx.ui.custom<string | null>((tui, theme, _keybindings, done) => {
+			return new ProjectFilePicker(ctx.cwd, files, theme as Theme, done, () =>
+				tui.requestRender(),
+			);
+		})) ?? null
+	);
 }
 
 async function ensureEmacsServer() {
 	state.serverStartPromise ??= (async () => {
+		stopLegacyDefaultServerIfNeeded();
+
 		try {
 			await emacsClient(["--eval", "(emacs-pid)"], { timeoutMs: 2000 });
+			state.startedEmacsServer = true;
+			startEmacsWatchdog("watch-existing");
 			return;
 		} catch {
-			// No reachable server. Start daemon below.
+			// No reachable named server. Start one under watchdog supervision.
 		}
 
-		console.log("[emacs] starting daemon...");
-		await run("emacs", ["--daemon"], { timeoutMs: 15000 });
+		startEmacsWatchdog("start-daemon");
+		await waitForEmacsServer(15000);
 		state.startedEmacsServer = true;
-		console.log("[emacs] daemon started");
-	})();
+	})().catch((error) => {
+		state.serverStartPromise = undefined;
+		throw error;
+	});
 
 	return state.serverStartPromise;
 }
 
 async function stopEmacsServer() {
-	if (!state.startedEmacsServer) return;
+	if (!state.startedEmacsServer && !state.serverStartPromise) return;
 
 	try {
 		await state.serverStartPromise;
 	} catch {
-		return;
+		// Start failure means there may be nothing to stop.
 	}
 
-	await emacsClient(["--eval", "(kill-emacs)"], { timeoutMs: 5000 });
+	try {
+		await emacsClient(["--eval", "(kill-emacs)"], { timeoutMs: 5000 });
+	} catch {
+		// Watchdog still handles parent-death cleanup if graceful stop fails.
+	}
 	state.startedEmacsServer = false;
 	state.serverStartPromise = undefined;
+	state.watchdogPid = undefined;
 }
 
-async function openEmacsClient(ctx: ExtensionContext) {
+function stopEmacsServerSync() {
+	if (!state.startedEmacsServer && !state.serverStartPromise) return;
+	emacsClientSync(["--eval", "(kill-emacs)"]);
+	state.startedEmacsServer = false;
+	state.serverStartPromise = undefined;
+	state.watchdogPid = undefined;
+}
+
+function installProcessShutdownHandler() {
+	const handlerVersion = 2;
+	if (state.processShutdownHandlerVersion === handlerVersion) return;
+	state.processShutdownHandlerVersion = handlerVersion;
+	process.on("exit", () => stopEmacsServerSync());
+}
+
+async function openEmacsWithArgs(
+	ctx: ExtensionContext,
+	args: string[],
+	errorPrefix = "Failed to start emacsclient",
+) {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("emacsclient requires TUI mode", "error");
 		return;
 	}
 
 	await ctx.ui.custom((tui, _theme, _keybindings, done) => {
-		emacsClient(emacsClientArgs(ctx.cwd), {
+		emacsClient(args, {
 			cwd: ctx.cwd,
 			stdio: "inherit",
 			onBefore: () => {
@@ -164,7 +965,7 @@ async function openEmacsClient(ctx: ExtensionContext) {
 		})
 			.then(() => done(null))
 			.catch((error) => {
-				ctx.ui.notify(`Failed to start emacsclient: ${error.message}`, "error");
+				ctx.ui.notify(`${errorPrefix}: ${error.message}`, "error");
 				done(null);
 			});
 
@@ -172,7 +973,43 @@ async function openEmacsClient(ctx: ExtensionContext) {
 	});
 }
 
+async function openEmacsClient(ctx: ExtensionContext) {
+	await openEmacsWithArgs(ctx, emacsClientArgs(ctx.cwd));
+}
+
+async function openEmacsPath(ctx: ExtensionContext, targetPath: string) {
+	state.lastEditedFile = statSync(targetPath).isDirectory()
+		? state.lastEditedFile
+		: targetPath;
+	await openEmacsWithArgs(ctx, [
+		"-nw",
+		"-a",
+		"",
+		"-e",
+		expressionForPath(targetPath),
+	]);
+}
+
+async function runFindFile(ctx: ExtensionContext) {
+	const targetPath = await choosePath(ctx);
+	if (targetPath) await openEmacsPath(ctx, targetPath);
+}
+
+async function runProjectFindFile(ctx: ExtensionContext) {
+	try {
+		const targetPath = await chooseProjectFile(ctx);
+		if (targetPath) await openEmacsPath(ctx, targetPath);
+	} catch (error) {
+		ctx.ui.notify(
+			`Failed to list project files: ${error instanceof Error ? error.message : String(error)}`,
+			"error",
+		);
+	}
+}
+
 export default function (pi: ExtensionAPI) {
+	installProcessShutdownHandler();
+
 	pi.on("session_start", () => {
 		ensureEmacsServer().catch((error) => {
 			console.error(`[emacs] failed to start server: ${error.message}`);
@@ -194,10 +1031,20 @@ export default function (pi: ExtensionAPI) {
 		handler: async (_args, ctx) => openEmacsClient(ctx),
 	});
 
+	pi.registerCommand("emacs:find-file", {
+		description: "Find and open a file or directory in Emacs",
+		handler: async (_args, ctx) => runFindFile(ctx),
+	});
+
+	pi.registerCommand("emacs:project-find-file", {
+		description: "Fuzzy-find a project file and open it in Emacs",
+		handler: async (_args, ctx) => runProjectFindFile(ctx),
+	});
+
 	pi.registerShortcut("ctrl+g", {
 		description: "Open emacsclient",
 		handler: openEmacsClient,
 	});
 }
 
-export { ensureEmacsServer, openEmacsClient, stopEmacsServer };
+export { ensureEmacsServer, openEmacsClient, openEmacsPath, stopEmacsServer };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@liushihao456/pi-emacs",
-  "version": "0.1.1",
-  "description": "Pi extension that opens emacsclient in a popup terminal and tracks recently edited files.",
+  "version": "0.1.3",
+  "description": "Pi extension that allows switching to emacs seamlessly in a popup terminal.",
   "type": "module",
   "keywords": [
     "pi-package",
@@ -30,5 +30,9 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "^0.79.2",
+    "@vscode/ripgrep": "^1.18.0"
   }
 }