@jerryan/pi-hashline-edit 0.7.3 → 0.8.1

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(
   {
@@ -68,15 +70,16 @@ type HashlineEditToolDetails = {
   snapshotId?: string;
   classification?: "noop";
   metrics?: EditMetrics;
+  package: { name: string; version: string };
 };
 
 const EDIT_DESC = readFileSync(
-  new URL("../prompts/edit.md", import.meta.url),
+  new URL("../tool-descriptions/edit.md", import.meta.url),
   "utf-8",
 ).trim();
 
 const EDIT_PROMPT_SNIPPET = readFileSync(
-  new URL("../prompts/edit-snippet.md", import.meta.url),
+  new URL("../tool-descriptions/edit-snippet.md", import.meta.url),
   "utf-8",
 ).trim();
 
@@ -107,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;
@@ -126,21 +196,66 @@ function getRenderablePreviewInput(args: unknown): EditRequestParams | null {
   return request.edits.length > 0 ? request : null;
 }
 
+function colorDiffLine(
+  line: string,
+  theme: { fg: (token: string, text: string) => string },
+): string {
+  const prefix = line[0];
+  if (prefix !== "-" && prefix !== "+" && prefix !== " ") {
+    return theme.fg("dim", line);
+  }
+  if (line.startsWith("---") || line.startsWith("+++")) {
+    return theme.fg("dim", line);
+  }
+
+  const sepIdx = line.indexOf(CONTENT_SEP);
+  if (sepIdx === -1) {
+    if (prefix === "-") return theme.fg("error", line);
+    if (prefix === "+") return theme.fg("success", line);
+    return theme.fg("dim", line);
+  }
+
+  const meta = line.slice(0, sepIdx); // prefix + lineNum + anchor/pad
+  const content = line.slice(sepIdx + CONTENT_SEP.length);
+
+  const digits = meta.match(/\d+/);
+  if (!digits) {
+    if (prefix === "-") return theme.fg("error", line);
+    if (prefix === "+") return theme.fg("success", line);
+    return theme.fg("dim", line);
+  }
+
+  const lineNumStart = meta.indexOf(digits[0]);
+  const lineNumEnd = lineNumStart + digits[0].length;
+  const prefixAndLineNum = meta.slice(0, lineNumEnd);
+  const anchorAndSep = meta.slice(lineNumEnd) + CONTENT_SEP;
+
+  if (prefix === "-") {
+    return (
+      theme.fg("error", prefixAndLineNum) +
+      theme.fg("muted", anchorAndSep) +
+      theme.fg("error", content)
+    );
+  }
+  if (prefix === "+") {
+    return (
+      theme.fg("success", prefixAndLineNum) +
+      theme.fg("muted", anchorAndSep) +
+      theme.fg("success", content)
+    );
+  }
+  return (
+    theme.fg("dim", prefixAndLineNum) +
+    theme.fg("muted", anchorAndSep) +
+    theme.fg("dim", content)
+  );
+}
 function colorDiffLines(
   lines: string[],
   theme: { fg: (token: string, text: string) => string },
 ): string[] {
-  return lines.map((line) => {
-    if (line.startsWith("+") && !line.startsWith("+++")) {
-      return theme.fg("success", line);
-    }
-    if (line.startsWith("-") && !line.startsWith("---")) {
-      return theme.fg("error", line);
-    }
-    return theme.fg("dim", line);
-  });
+  return lines.map((line) => colorDiffLine(line, theme));
 }
-
 function formatPreviewDiff(
   diff: string,
   expanded: boolean,
@@ -148,7 +263,7 @@ function formatPreviewDiff(
 ): string {
   const lines = diff.split("\n");
   const maxLines = expanded ? 40 : 16;
-  const shown = colorDiffLines(lines.slice(0, maxLines), theme);
+  const shown = lines.slice(0, maxLines).map((line) => colorDiffLine(line, theme));
 
   if (lines.length > maxLines) {
     shown.push(theme.fg("muted", `... ${lines.length - maxLines} more diff lines`));
@@ -160,9 +275,8 @@ function formatResultDiff(
   diff: string,
   theme: { fg: (token: string, text: string) => string },
 ): string {
-  return colorDiffLines(diff.split("\n"), theme).join("\n");
+  return diff.split("\n").map((line) => colorDiffLine(line, theme)).join("\n");
 }
-
 function getRenderedEditTextContent(
   result: { content?: Array<{ type: string; text?: string }> },
 ): string | undefined {
@@ -249,36 +363,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 UTF-8 text files.`,
-      };
-    }
-    if (file.kind === "binary") {
-      return {
-        error: `Path is a binary file: ${path} (${file.description}). Hashline edit only supports UTF-8 text files.`,
-      };
-    }
-
-    const originalNormalized = normalizeToLF(stripBom(file.text).text);
     const resolved = resolveEditAnchors(toolEdits);
     const result = applyHashlineEdits(originalNormalized, resolved).content;
 
@@ -433,48 +524,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}`);
-      }
-
-      throwIfAborted(signal);
-      const file = await loadFileKindAndText(absolutePath);
-      if (file.kind === "directory") {
-        throw new Error(`Path is a directory: ${path}. Use ls to inspect directories.`);
+      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}`);
       }
-      if (file.kind === "image") {
-        throw new Error(
-          `Path is an image file: ${path}. Hashline edit only supports UTF-8 text files.`,
-        );
-      }
-      if (file.kind === "binary") {
-        throw new Error(
-          `Path is a binary file: ${path} (${file.description}). Hashline edit only supports UTF-8 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.",
@@ -494,7 +557,7 @@ const editToolDefinition: EditToolDefinition = {
           warnings,
         });
       }
-
+      setLastEdit({ path, previousContent: originalNormalized });
       throwIfAborted(signal);
       await writeFileAtomically(
         absolutePath,

package/src/file-kind.ts

@@ -1,167 +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);
-}
-
-function decodeUtf8Chunk(decoder: TextDecoder, buffer: Uint8Array): string | null {
-  try {
-    return decoder.decode(buffer, { stream: true });
-  } catch (error: unknown) {
-    if (error instanceof TypeError) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-function finishUtf8(decoder: TextDecoder): string | null {
-  try {
-    return decoder.decode();
-  } catch (error: unknown) {
-    if (error instanceof TypeError) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-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",
-      };
-    }
-
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    const parts: string[] = [];
-    const sampleText = decodeUtf8Chunk(decoder, sample);
-    if (sampleText === null) {
-      return {
-        kind: "binary",
-        description: "invalid UTF-8",
-      };
-    }
-    parts.push(sampleText);
-
-    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",
-        };
-      }
-      const chunkText = decodeUtf8Chunk(decoder, chunk);
-      if (chunkText === null) {
-        return {
-          kind: "binary",
-          description: "invalid UTF-8",
-        };
-      }
-      parts.push(chunkText);
-      position += chunkBytesRead;
-    }
-
-    const tail = finishUtf8(decoder);
-    if (tail === null) {
-      return {
-        kind: "binary",
-        description: "invalid UTF-8",
-      };
-    }
-    parts.push(tail);
-
-    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" };
+  }
+}