pi-hashline-edit-pro 0.2.0

package/src/file-kind.ts

@@ -0,0 +1,161 @@
+import { open as fsOpen, stat as fsStat } from "fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+
+const IMAGE_MIME_TYPES = new Set<string>([
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+]);
+
+const TEXT_LIKE_MIME_TYPES = new Set<string>([
+	"application/rtf",
+	"application/xml",
+	"application/x-ms-regedit",
+]);
+
+function isTextLikeMimeType(mimeType: string): boolean {
+	return mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+}
+
+const FILE_TYPE_SNIFF_BYTES = 8192;
+
+export type FileKind =
+	| { kind: "directory" }
+	| { kind: "image"; mimeType: string }
+	| { kind: "text" }
+	| { kind: "binary"; description: string };
+
+export type LoadedFile =
+	| { kind: "directory" }
+	| { kind: "image"; mimeType: string }
+	| { kind: "text"; text: string; hadUtf8DecodeErrors?: true }
+	| { kind: "binary"; description: string };
+
+function hasNullByte(buffer: Uint8Array): boolean {
+	return buffer.includes(0);
+}
+
+export async function loadFileKindAndText(
+	filePath: string,
+): Promise<LoadedFile> {
+	const pathStat = await fsStat(filePath);
+	if (pathStat.isDirectory()) {
+		return { kind: "directory" };
+	}
+	if (!pathStat.isFile()) {
+		return {
+			kind: "binary",
+			description: "unsupported file type",
+		};
+	}
+
+	const fileHandle = await fsOpen(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+		const { bytesRead } = await fileHandle.read(
+			buffer,
+			0,
+			FILE_TYPE_SNIFF_BYTES,
+			0,
+		);
+		if (bytesRead === 0) {
+			return { kind: "text", text: "" };
+		}
+
+		const sample = buffer.subarray(0, bytesRead);
+		const detectedMimeType = (await fileTypeFromBuffer(sample))?.mime;
+		if (
+			detectedMimeType !== undefined &&
+			!isTextLikeMimeType(detectedMimeType)
+		) {
+			if (IMAGE_MIME_TYPES.has(detectedMimeType)) {
+				return { kind: "image", mimeType: detectedMimeType };
+			}
+			return {
+				kind: "binary",
+				description: detectedMimeType,
+			};
+		}
+		if (hasNullByte(sample)) {
+			return {
+				kind: "binary",
+				description: "null bytes detected",
+			};
+		}
+
+		// Non-fatal decode, matching pi's built-in tools: invalid UTF-8 becomes
+		// U+FFFD rather than rejecting the file. The null-byte guard above is the
+		// only signal we treat as binary, so non-UTF-8 text (CP1251, GBK, …) reads
+		// instead of forcing the model to bypass hashline with raw shell edits.
+		// Track fatal-decoder failures separately so a literal, valid U+FFFD in a
+		// UTF-8 file does not get mistaken for lossy decoding.
+		const decoder = new TextDecoder("utf-8");
+		const fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+		let hadUtf8DecodeErrors = false;
+		const noteUtf8DecodeErrors = (chunk?: Uint8Array): void => {
+			if (hadUtf8DecodeErrors) return;
+			try {
+				fatalDecoder.decode(chunk, { stream: chunk !== undefined });
+			} catch (error: unknown) {
+				if (error instanceof TypeError) {
+					hadUtf8DecodeErrors = true;
+					return;
+				}
+				throw error;
+			}
+		};
+
+		noteUtf8DecodeErrors(sample);
+		const parts: string[] = [decoder.decode(sample, { stream: true })];
+
+		let position = bytesRead;
+		while (true) {
+			const { bytesRead: chunkBytesRead } = await fileHandle.read(
+				buffer,
+				0,
+				FILE_TYPE_SNIFF_BYTES,
+				position,
+			);
+			if (chunkBytesRead === 0) {
+				break;
+			}
+
+			const chunk = buffer.subarray(0, chunkBytesRead);
+			if (hasNullByte(chunk)) {
+				return {
+					kind: "binary",
+					description: "null bytes detected",
+				};
+			}
+			noteUtf8DecodeErrors(chunk);
+			parts.push(decoder.decode(chunk, { stream: true }));
+			position += chunkBytesRead;
+		}
+
+		noteUtf8DecodeErrors();
+		parts.push(decoder.decode());
+
+		return {
+			kind: "text",
+			text: parts.join(""),
+			...(hadUtf8DecodeErrors ? { hadUtf8DecodeErrors: true as const } : {}),
+		};
+	} finally {
+		await fileHandle.close();
+	}
+}
+
+export async function classifyFileKind(filePath: string): Promise<FileKind> {
+	const loaded = await loadFileKindAndText(filePath);
+	switch (loaded.kind) {
+		case "directory":
+			return loaded;
+		case "image":
+			return loaded;
+		case "binary":
+			return loaded;
+		case "text":
+			return { kind: "text" };
+	}
+}

package/src/fs-write.ts

@@ -0,0 +1,105 @@
+import { randomUUID } from "crypto";
+import {
+	lstat,
+	mkdir,
+	open,
+	readlink,
+	rename,
+	stat,
+	writeFile,
+} from "fs/promises";
+import { dirname, join, parse, resolve, sep } from "path";
+
+export async function resolveMutationTargetPath(path: string): Promise<string> {
+	const absolutePath = resolve(path);
+	const { root } = parse(absolutePath);
+	const parts = absolutePath
+		.slice(root.length)
+		.split(sep)
+		.filter((part) => part.length > 0);
+	const visitedSymlinks = new Set<string>();
+
+	async function resolveFromParts(
+		currentPath: string,
+		remainingParts: string[],
+	): Promise<string> {
+		if (remainingParts.length === 0) {
+			return currentPath;
+		}
+
+		const [nextPart, ...tail] = remainingParts;
+		const candidatePath = join(currentPath, nextPart);
+
+		try {
+			const candidateStats = await lstat(candidatePath);
+			if (!candidateStats.isSymbolicLink()) {
+				return resolveFromParts(candidatePath, tail);
+			}
+
+			if (visitedSymlinks.has(candidatePath)) {
+				const error = new Error(
+					`Too many symbolic links while resolving ${path}`,
+				) as NodeJS.ErrnoException;
+				error.code = "ELOOP";
+				throw error;
+			}
+			visitedSymlinks.add(candidatePath);
+
+			const linkTargetPath = resolve(
+				dirname(candidatePath),
+				await readlink(candidatePath),
+			);
+			const targetParts = linkTargetPath
+				.slice(parse(linkTargetPath).root.length)
+				.split(sep)
+				.filter((part) => part.length > 0);
+			return resolveFromParts(parse(linkTargetPath).root, [
+				...targetParts,
+				...tail,
+			]);
+		} catch (error: unknown) {
+			if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+				return join(candidatePath, ...tail);
+			}
+			throw error;
+		}
+	}
+
+	return resolveFromParts(root, parts);
+}
+
+export async function writeFileAtomically(
+	path: string,
+	content: string,
+): Promise<void> {
+	const targetPath = await resolveMutationTargetPath(path);
+
+	let existingStats: Awaited<ReturnType<typeof stat>> | null = null;
+	try {
+		existingStats = await stat(targetPath);
+	} catch (error: unknown) {
+		if ((error as NodeJS.ErrnoException)?.code !== "ENOENT") {
+			throw error;
+		}
+	}
+
+	if (existingStats && existingStats.nlink > 1) {
+		await writeFile(targetPath, content, "utf-8");
+		return;
+	}
+
+	const dir = dirname(targetPath);
+	const tempPath = join(dir, `.tmp-${randomUUID()}`);
+	await mkdir(dir, { recursive: true });
+	const tempHandle = await open(tempPath, "wx", 0o600);
+	try {
+		await tempHandle.writeFile(content, "utf-8");
+		if (existingStats) {
+			await tempHandle.chmod(existingStats.mode & 0o7777);
+		}
+	} finally {
+		await tempHandle.close();
+	}
+
+	await rename(tempPath, targetPath);
+}