pi-readseek 0.3.17 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {

package/src/coerce-obvious-int.ts

@@ -4,16 +4,7 @@ type CoercedIntResult =
   | { ok: true; value: number | undefined }
   | { ok: false; message: string };
 
-export function coerceObviousBase10Int(value: unknown): unknown;
-export function coerceObviousBase10Int(value: unknown, name: string): CoercedIntResult;
-export function coerceObviousBase10Int(value: unknown, name?: string): unknown | CoercedIntResult {
-  if (name === undefined) {
-    if (typeof value === "string" && BASE10_INT_RE.test(value)) {
-      return Number.parseInt(value, 10);
-    }
-    return value;
-  }
-
+export function coerceObviousBase10Int(value: unknown, name: string): CoercedIntResult {
   if (value === undefined) {
     return { ok: true, value: undefined };
   }

package/src/diff-data.ts

@@ -99,7 +99,6 @@ function parseFullDiffEntries(diff: string): DiffEntry[] {
     entries.push({ kind: "meta", text: line });
   }
 
-  void nextOldLine;
   return entries;
 }
 

package/src/edit-diff.ts

@@ -4,10 +4,19 @@ import { CONFUSABLE_HYPHENS_RE } from "./confusable-hyphens.js";
 
 
 export function detectLineEnding(content: string): "\r\n" | "\n" {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1 || crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
+	let crlf = 0;
+	let lf = 0;
+	for (let i = 0; i < content.length; i++) {
+		if (content[i] === "\r" && i + 1 < content.length && content[i + 1] === "\n") {
+			crlf++;
+			i++;
+		} else if (content[i] === "\n") {
+			lf++;
+		}
+	}
+	if (lf === 0) return "\r\n";
+	if (crlf === 0) return "\n";
+	return crlf > lf ? "\r\n" : "\n";
 }
 
 export function normalizeToLF(text: string): string {

package/src/edit-syntax-validate.ts

@@ -51,7 +51,7 @@ export async function validateSyntaxRegression(
     return null;
   }
 
-  const newErrorCount = Math.max(0, after.errorCount - before.errorCount - 1);
+  const newErrorCount = Math.max(0, after.errorCount - before.errorCount);
   const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
 
   if (newErrorCount === 0 && newMissingCount === 0) return null;

package/src/edit.ts

@@ -116,6 +116,26 @@ function buildEditError(
 	};
 }
 
+function mapEditFileError(err: any, filePath: string, displayPath: string, phase: "read" | "write"): ReturnType<typeof buildEditError> {
+	const code = err?.code;
+	if (code === "EISDIR") {
+		return buildEditError(filePath, "path-is-directory",
+			`Path is a directory: ${displayPath}`,
+			`Use ls(${JSON.stringify(displayPath)}) to inspect directories.`);
+	}
+	if (code === "ENOENT") {
+		return buildEditError(filePath, "file-not-found",
+			`${phase === "write" ? "Failed to write file" : "File not found"}: ${displayPath}`);
+	}
+	if (code === "EACCES" || code === "EPERM") {
+		return buildEditError(filePath, "permission-denied", `Permission denied: ${displayPath}`);
+	}
+	const prefix = phase === "write" ? "Failed to write file" : "File not readable";
+	const message = `${prefix}: ${displayPath}${err?.message ? ` — ${err.message}` : ""}`;
+	return buildEditError(filePath, "fs-error", message, undefined,
+		{ fsCode: code, fsMessage: err?.message });
+}
+
 export interface EditToolOptions {
 	wasReadInSession?: (absolutePath: string) => boolean;
 	syntaxValidate?: SyntaxValidateOptions["syntaxValidate"];
@@ -227,27 +247,7 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			try {
 				rawBuffer = await fsReadFile(absolutePath);
 			} catch (err: any) {
-				const code = err?.code;
-				let errCode: string;
-				let message: string;
-				let hint: string | undefined;
-				let errorDetails: { fsCode?: string; fsMessage?: string } | undefined;
-				if (code === "EISDIR") {
-					errCode = "path-is-directory";
-					message = `Path is a directory: ${path}`;
-					hint = `Use ls(${JSON.stringify(path)}) to inspect directories.`;
-				} else if (code === "ENOENT") {
-					errCode = "file-not-found";
-					message = `File not found: ${path}`;
-				} else if (code === "EACCES" || code === "EPERM") {
-					errCode = "permission-denied";
-					message = `Permission denied: ${path}`;
-				} else {
-					errCode = "fs-error";
-					message = `File not readable: ${path}${err?.message ? ` — ${err.message}` : ""}`;
-					errorDetails = { fsCode: code, fsMessage: err?.message };
-				}
-				return buildEditError(absolutePath, errCode, message, hint, errorDetails);
+				return mapEditFileError(err, absolutePath, path, "read");
 			}
 			if (isBinaryBuffer(rawBuffer)) {
 				const message = `Cannot edit binary file: ${path}`;
@@ -258,6 +258,27 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			const { bom, text: content } = stripBom(raw);
 			const originalEnding = detectLineEnding(content);
 			const originalNormalized = normalizeToLF(content);
+			const origLines = originalNormalized.split("\n");
+			const anchorSnapshots = new Map<string, string>();
+			for (const edit of anchorEdits) {
+				const refs: string[] = [];
+				if ("set_line" in edit) refs.push(edit.set_line.anchor);
+				else if ("replace_lines" in edit) {
+					refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+				} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
+				for (const ref of refs) {
+					try {
+						const parsed = parseLineRef(ref);
+						if (parsed.line >= 1 && parsed.line <= origLines.length) {
+							const lineContent = origLines[parsed.line - 1];
+							const hash = computeLineHash(parsed.line, lineContent);
+							anchorSnapshots.set(ref, `${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
+						}
+					} catch {
+						/* skip malformed refs */
+					}
+				}
+			}
 			let preAnchorContent = originalNormalized;
 			// AC 26: reject anchored edits that target a line inside any replace_symbol
 			// pre-replace range. Resolve each target against the ORIGINAL content so the
@@ -302,8 +323,8 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 						let startLine: number | undefined;
 						let endLine: number | undefined;
 						try {
-							startLine = parseLineRef((edit as any).replace_lines.start_anchor).line;
-							endLine = parseLineRef((edit as any).replace_lines.end_anchor).line;
+							startLine = parseLineRef(edit.replace_lines.start_anchor).line;
+							endLine = parseLineRef(edit.replace_lines.end_anchor).line;
 						} catch {
 							// Let the normal anchored edit validation report malformed anchors later.
 						}
@@ -319,10 +340,10 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 						}
 					}
 					const refs: string[] = [];
-					if ("set_line" in edit) refs.push((edit as any).set_line.anchor);
+					if ("set_line" in edit) refs.push(edit.set_line.anchor);
 					else if ("replace_lines" in edit) {
-						refs.push((edit as any).replace_lines.start_anchor, (edit as any).replace_lines.end_anchor);
-					} else if ("insert_after" in edit) refs.push((edit as any).insert_after.anchor);
+						refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+					} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
 					for (const ref of refs) {
 						let parsedLine: number | undefined;
 						try {
@@ -412,30 +433,9 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 							.join("\n");
 					diagnostic += "\nRe-read the file to see the current state.";
 				} else {
-					// Edits were not literally identical but heuristics normalized them back
-					const lines = result.split("\n");
-					const targetLines: string[] = [];
-					for (const edit of edits) {
-						const refs: string[] = [];
-						if ("set_line" in edit) refs.push((edit as any).set_line.anchor);
-						else if ("replace_lines" in edit) {
-							refs.push((edit as any).replace_lines.start_anchor, (edit as any).replace_lines.end_anchor);
-						} else if ("insert_after" in edit) refs.push((edit as any).insert_after.anchor);
-						for (const ref of refs) {
-							try {
-								const parsed = parseLineRef(ref);
-								if (parsed.line >= 1 && parsed.line <= lines.length) {
-									const lineContent = lines[parsed.line - 1];
-									const hash = computeLineHash(parsed.line, lineContent);
-									targetLines.push(`${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
-								}
-							} catch {
-								/* skip malformed refs */
-							}
-						}
-					}
+					const targetLines = [...new Set(anchorSnapshots.values())];
 					if (targetLines.length > 0) {
-						const preview = [...new Set(targetLines)].slice(0, 5).join("\n");
+						const preview = targetLines.slice(0, 5).join("\n");
 						diagnostic += `\nThe file currently contains:\n${preview}\nYour edits were normalized back to the original content. Ensure your replacement changes actual code, not just formatting.`;
 					}
 				}
@@ -467,18 +467,7 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			try {
 				await fsWriteFile(absolutePath, writeContent, "utf-8");
 			} catch (err: any) {
-				const wrapped = wrapWriteError(err, path);
-				const code =
-					err?.code === "EACCES" || err?.code === "EPERM"
-						? "permission-denied"
-						: err?.code === "ENOENT"
-							? "file-not-found"
-							: "fs-error";
-				const message =
-					code === "fs-error" && err?.message ? `${wrapped.message} — ${err.message}` : wrapped.message;
-				return buildEditError(absolutePath, code, message, undefined, code === "fs-error"
-					? { fsCode: err?.code, fsMessage: err?.message }
-					: undefined);
+				return mapEditFileError(err, absolutePath, path, "write");
 			}
 
 			if (input.postEditVerify === true) {
@@ -555,7 +544,6 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 				semanticSummary,
 			});
 
-			const warn = warnings.length ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
 			return {
 				content: [{ type: "text", text: builtOutput.text }],
 				details: {
@@ -581,10 +569,8 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			};
 				});
 			} catch (err: any) {
-				const code = err?.code;
-				if (typeof code === "string") {
-					const message = `File not readable: ${path}${err?.message ? ` — ${err.message}` : ""}`;
-					return buildEditError(absolutePath, "fs-error", message, undefined, { fsCode: code, fsMessage: err?.message });
+				if (typeof err?.code === "string") {
+					return mapEditFileError(err, absolutePath, path, "read");
 				}
 				throw err;
 			}

package/src/readseek-settings.ts

@@ -49,18 +49,6 @@ function readPositive(
   return undefined;
 }
 
-function readBoolean(
-  raw: Record<string, unknown>,
-  key: string,
-  path: string,
-  source: string,
-  warnings: ReadseekSettingsWarning[],
-): boolean | undefined {
-  if (!(key in raw)) return undefined;
-  if (typeof raw[key] === "boolean") return raw[key];
-  warnings.push(invalid(source, path));
-  return undefined;
-}
 
 function validateSettings(raw: unknown, source: string): ReadseekSettingsResult {
   const settings: ReadseekJsonSettings = {};

package/src/replace-symbol.ts

@@ -53,9 +53,11 @@ export async function replaceSymbol(input: ReplaceSymbolInput): Promise<ReplaceS
 	const reindented = reindent(dedent(input.newBody), indent);
 	const warnings: string[] = [];
 	const leaf = input.symbol.replace(/@\d+$/, "").split(".").pop() ?? "";
+	const declNameRe =
+		/\b(?:(?:export\s+(?:default\s+)?|async\s+|public\s+|private\s+|protected\s+|static\s+)*)(?:function\*?|class|const|let|var|fn|def|method|type|interface|enum)\s+([A-Za-z_$][\w$]*)/s;
 	const firstDeclName =
-		reindented.match(/\b(?:function|class|method|const|let|var)\s+([A-Za-z_$][\w$]*)/)?.[1]
-		?? reindented.match(/^\s*(?:[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
+		reindented.match(declNameRe)?.[1]
+		?? reindented.match(/^\s*(?:(?:async\s+)?[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
 	if (leaf && firstDeclName && firstDeclName !== leaf) {
 		warnings.push(`name-mismatch: expected ${leaf}, got ${firstDeclName}`);
 	}

package/src/write.ts

@@ -294,7 +294,7 @@ export async function executeWrite(opts: {
       warnings: readseekWarnings,
       diff: diffResult.diff,
       diffData,
-      ...(requestMap !== undefined ? { map: { appended: mapAppended } } : {}),
+      ...(requestMap ? { map: { appended: mapAppended } } : {}),
     },
   };
 }