@jerryan/pi-hashline-edit 0.7.4 → 0.8.2

package/src/edit.ts

@@ -18,6 +18,7 @@ import {
   resolveEditAnchors,
   type HashlineToolEdit,
   ANCHOR_SEP,
+  CONTENT_SEP,
 } from "./hashline";
 import { loadFileKindAndText } from "./file-kind";
 import { resolveToCwd } from "./path-utils";
@@ -25,6 +26,7 @@ import { resolveToCwd } from "./path-utils";
 import { throwIfAborted } from "./runtime";
 import { getFileSnapshot } from "./snapshot";
 import { buildChangedResponse, buildNoopResponse } from "./edit-response";
+import { setLastEdit } from "./undo";
 
 const editEntrySchema = Type.Object(
   {
@@ -108,6 +110,73 @@ export function normalizeEditItems(edits: Record<string, unknown>[]): HashlineTo
   });
 }
 
+type EditTargetResult =
+  | { ok: false; error: string; code?: string }
+  | {
+      ok: true;
+      normalized: string;
+      bom: string;
+      ending: "\r\n" | "\n";
+    };
+
+async function resolveEditTarget(
+  absolutePath: string,
+  path: string,
+  accessMode: number,
+): Promise<EditTargetResult> {
+  try {
+    await fsAccess(absolutePath, accessMode);
+  } catch (error: unknown) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT") {
+      return { ok: false, error: `File not found: ${path}` };
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      const action = accessMode & constants.W_OK ? "writable" : "readable";
+      return { ok: false, error: `File is not ${action}: ${path}` };
+    }
+    return { ok: false, error: `Cannot access file: ${path}` };
+  }
+
+  const file = await loadFileKindAndText(absolutePath);
+  if (file.kind === "directory") {
+    return {
+      ok: false,
+      error: `Path is a directory: ${path}. Use ls to inspect directories.`,
+    };
+  }
+  if (file.kind === "image") {
+    return {
+      ok: false,
+      error: `Path is an image file: ${path}. Hashline edit only supports text files.`,
+    };
+  }
+  if (file.kind === "binary") {
+    return {
+      ok: false,
+      error: `Path is a binary file: ${path} (${file.description}). Hashline edit only supports text files.`,
+    };
+  }
+
+  const { bom, text: content } = stripBom(file.text);
+  const normalized = normalizeToLF(content);
+  if (normalized.length === 0) {
+    return {
+      ok: false,
+      code: "E_EMPTY_FILE",
+      error: `File is empty: ${path}. The edit tool requires anchors from a read output, which an empty file cannot provide. Use the write tool to create initial content in an empty file.`,
+    };
+  }
+
+  return {
+    ok: true,
+    normalized,
+    bom,
+    ending: detectLineEnding(content),
+  };
+}
+
+
 type EditPreview = { diff: string } | { error: string };
 type EditRenderState = {
   argsKey?: string;
@@ -141,7 +210,6 @@ function colorDiffLines(
     return theme.fg("dim", line);
   });
 }
-
 function formatPreviewDiff(
   diff: string,
   expanded: boolean,
@@ -163,7 +231,6 @@ function formatResultDiff(
 ): string {
   return colorDiffLines(diff.split("\n"), theme).join("\n");
 }
-
 function getRenderedEditTextContent(
   result: { content?: Array<{ type: string; text?: string }> },
 ): string | undefined {
@@ -250,36 +317,13 @@ export async function computeEditPreview(
   const absolutePath = resolveToCwd(path, cwd);
   const toolEdits = normalizeEditItems(params.edits);
 
-  try {
-    await fsAccess(absolutePath, constants.R_OK);
-  } catch (error: unknown) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code === "ENOENT") {
-      return { error: `File not found: ${path}` };
-    }
-    if (code === "EACCES" || code === "EPERM") {
-      return { error: `File is not readable: ${path}` };
-    }
-    return { error: `Cannot access file: ${path}` };
+  const target = await resolveEditTarget(absolutePath, path, constants.R_OK);
+  if (!target.ok) {
+    return { error: target.error };
   }
+  const originalNormalized = target.normalized;
 
   try {
-    const file = await loadFileKindAndText(absolutePath);
-    if (file.kind === "directory") {
-      return { error: `Path is a directory: ${path}. Use ls to inspect directories.` };
-    }
-    if (file.kind === "image") {
-      return {
-        error: `Path is an image file: ${path}. Hashline edit only supports text files.`,
-      };
-    }
-    if (file.kind === "binary") {
-      return {
-        error: `Path is a binary file: ${path} (${file.description}). Hashline edit only supports text files.`,
-      };
-    }
-
-    const originalNormalized = normalizeToLF(stripBom(file.text).text);
     const resolved = resolveEditAnchors(toolEdits);
     const result = applyHashlineEdits(originalNormalized, resolved).content;
 
@@ -434,48 +478,20 @@ const editToolDefinition: EditToolDefinition = {
     const mutationTargetPath = await resolveMutationTargetPath(absolutePath);
     return withFileMutationQueue(mutationTargetPath, async () => {
       throwIfAborted(signal);
-      try {
-        await fsAccess(absolutePath, constants.R_OK | constants.W_OK);
-      } catch (error: unknown) {
-        const code = (error as NodeJS.ErrnoException).code;
-        if (code === "ENOENT") {
-          throw new Error(`File not found: ${path}`);
-        }
-        if (code === "EACCES" || code === "EPERM") {
-          throw new Error(`File is not writable: ${path}`);
-        }
-        throw new Error(`Cannot access file: ${path}`);
+      const target = await resolveEditTarget(absolutePath, path, constants.R_OK | constants.W_OK);
+      if (!target.ok) {
+        const prefix = target.code ? `[${target.code}] ` : "";
+        throw new Error(`${prefix}${target.error}`);
       }
-
-      throwIfAborted(signal);
-      const file = await loadFileKindAndText(absolutePath);
-      if (file.kind === "directory") {
-        throw new Error(`Path is a directory: ${path}. Use ls to inspect directories.`);
-      }
-      if (file.kind === "image") {
-        throw new Error(
-          `Path is an image file: ${path}. Hashline edit only supports text files.`,
-        );
-      }
-      if (file.kind === "binary") {
-        throw new Error(
-          `Path is a binary file: ${path} (${file.description}). Hashline edit only supports text files.`,
-        );
-      }
-
-      throwIfAborted(signal);
-      const { bom, text: content } = stripBom(file.text);
-      const originalEnding = detectLineEnding(content);
-      const originalNormalized = normalizeToLF(content);
+      const { bom, normalized: originalNormalized, ending: originalEnding } = target;
 
       const resolved = resolveEditAnchors(toolEdits);
 
+
       const anchorResult = applyHashlineEdits(originalNormalized, resolved, signal);
       const result = anchorResult.content;
       const warnings = anchorResult.warnings;
-      const originalLineCount = originalNormalized.length === 0
-        ? 0
-        : originalNormalized.split("\n").length - (originalNormalized.endsWith("\n") ? 1 : 0);
+      const originalLineCount = originalNormalized.split("\n").length - (originalNormalized.endsWith("\n") ? 1 : 0);
       if (result.length === 0 && originalLineCount > 50) {
         throw new Error(
           "[E_WOULD_EMPTY] This edit would delete the entire file. The edit tool does not allow full-file deletion for files with more than 50 lines. If you truly intend to clear the file, use the write tool to overwrite it with an empty string.",
@@ -495,7 +511,7 @@ const editToolDefinition: EditToolDefinition = {
           warnings,
         });
       }
-
+      setLastEdit({ path, previousContent: originalNormalized });
       throwIfAborted(signal);
       await writeFileAtomically(
         absolutePath,

package/src/file-kind.ts

@@ -1,130 +1,130 @@
-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 }
-  | { 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.
-    const decoder = new TextDecoder("utf-8");
-    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",
-        };
-      }
-      parts.push(decoder.decode(chunk, { stream: true }));
-      position += chunkBytesRead;
-    }
-
-    parts.push(decoder.decode());
-
-    return { kind: "text", text: parts.join("") };
-
-    return { kind: "text", text: parts.join("") };
-  } 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" };
-  }
-}
+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 }
+  | { 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.
+    const decoder = new TextDecoder("utf-8");
+    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",
+        };
+      }
+      parts.push(decoder.decode(chunk, { stream: true }));
+      position += chunkBytesRead;
+    }
+
+    parts.push(decoder.decode());
+
+    return { kind: "text", text: parts.join("") };
+
+    return { kind: "text", text: parts.join("") };
+  } 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

@@ -1,76 +1,76 @@
-import { randomUUID } from "crypto";
-import { lstat, mkdir, 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 mode = existingStats ? existingStats.mode & 0o7777 : 0o600;
-  await writeFile(tempPath, content, { encoding: "utf-8", flag: "wx", mode });
-
-  await rename(tempPath, targetPath);
-}
+import { randomUUID } from "crypto";
+import { lstat, mkdir, 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 mode = existingStats ? existingStats.mode & 0o7777 : 0o600;
+  await writeFile(tempPath, content, { encoding: "utf-8", flag: "wx", mode });
+
+  await rename(tempPath, targetPath);
+}