pi-hashline-edit-pro 4.4.4 → 4.5.0

package/src/paths.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { isAbsolute, relative, resolve as resolvePath, join, dirname } from "node:path";
+import { isAbsolute, relative, resolve as resolvePath, join, dirname, parse } from "node:path";
 
 
 function homeBase(): string {
@@ -55,6 +55,22 @@ export function toCwd(filePath: string, cwd: string): string {
   return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
 }
 
+function pathDepth(path: string): number {
+  const root = parse(path).root;
+  return path.slice(root.length).split(/[\\/]+/).filter((part) => part.length > 0).length;
+}
+
+function climbsToRoot(cwd: string, relativePath: string): boolean {
+  let climbs = 0;
+  for (const part of relativePath.split("/")) {
+    if (part !== "..") break;
+    climbs += 1;
+  }
+  return climbs > 0 && climbs >= pathDepth(resolvePath(cwd));
+}
+
 export function toDisplayPath(cwd: string, absolutePath: string, fallback?: string): string {
-  return relative(cwd, absolutePath).replace(/\\/g, "/") || (fallback ?? absolutePath);
+  const rel = relative(cwd, absolutePath).replace(/\\/g, "/");
+  if (rel.length === 0 || climbsToRoot(cwd, rel)) return fallback ?? absolutePath;
+  return rel;
 }

package/src/payload-contract.ts

@@ -4,7 +4,7 @@ import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./uti
 const replacementLinesSchema = Type.Array(
   Type.String({
     description:
-      "One replacement line; never embed \\n inside an element.",
+      "One replacement line. A real line break (\\n, \\r\\n, or \\r) splits it into lines and sets their endings; escape sequences are not decoded.",
   }),
   {
     description:
@@ -131,3 +131,31 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
   }
   assertNoNul(request.lines);
 }
+
+const TRANSFER_KEYS = new Set(["path", "source_from", "source_to", "insert_after"]);
+
+export interface TransferReq {
+  path?: string;
+  source_from: string;
+  source_to: string;
+  insert_after: string;
+}
+
+export function assertTransferReq(request: unknown): asserts request is TransferReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Copy/move request must be an object.");
+  }
+  rejectUnknownFields(request, TRANSFER_KEYS, "Copy/move request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Copy/move request field "path" must be a string when provided.');
+  }
+  if (typeof request.source_from !== "string" || request.source_from.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires a "source_from" string (4-char anchor from read output).');
+  }
+  if (typeof request.source_to !== "string" || request.source_to.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires a "source_to" string (4-char anchor from read output).');
+  }
+  if (typeof request.insert_after !== "string" || request.insert_after.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires an "insert_after" string (4-char anchor from read output).');
+  }
+}

package/src/replace-render.ts

@@ -81,7 +81,7 @@ export function highlightBatchRefs(text: string, theme: FgT): string {
 }
 
 export function fmtCall(
-  args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | undefined,
+  args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string } | undefined,
   state: RRState,
   expanded: boolean,
   theme: CallT,
@@ -89,7 +89,7 @@ export function fmtCall(
 ): string {
   const previewPath = state.preview && "path" in state.preview ? state.preview.path : undefined;
   const path = args?.path ?? state.resolvedPath ?? previewPath;
-  const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : undefined;
+  const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : typeof args?.source_from === "string" && typeof args?.insert_after === "string" ? `${args.source_from}→${args.insert_after}` : undefined;
   const pathDisplay =
     typeof path === "string" && path.length > 0
       ? theme.fg("accent", path)
@@ -264,9 +264,9 @@ export function reuseMarkdown(context: any, content: string, theme: any): Markdo
 export function makeRenderCall(
 	preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
   options: {
-    getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | null;
+    getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string } | null;
     toolName?: string;
-    resolveTarget?: (input: { remove_from?: string; remove_to?: string; anchor?: string }) => string | undefined;
+    resolveTarget?: (input: { remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string }) => string | undefined;
   } = {},
 ) {
 	const getInput = options.getInput ?? getPreviewInput;

package/src/replace-undo.ts

@@ -9,6 +9,7 @@ import { lineChecksum } from "./hashline";
 import { freeAnchors, adoptAnchors, withAnchorSession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
+import { joinSeparators } from "./line-endings";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
 import { getDiffContextLines } from "./config";
 import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
@@ -22,8 +23,10 @@ export interface UndoEntry {
   content: string;
   bom: string;
   originalEnding: LineEnding;
+  separators?: LineEnding[];
   hashes: string[];
   resultContent: string;
+  resultSeparators?: LineEnding[];
   mode?: number;
 }
 
@@ -44,8 +47,10 @@ export async function saveUndo(
       content: entry.content,
       bom: entry.bom,
       ending: entry.originalEnding,
+      ...(entry.separators !== undefined ? { separators: entry.separators } : {}),
       hashes: entry.hashes,
       resultContent: entry.resultContent,
+      ...(entry.resultSeparators !== undefined ? { resultSeparators: entry.resultSeparators } : {}),
       ...(mode !== undefined ? { mode } : {}),
     });
   } catch (error) {
@@ -80,8 +85,10 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       content: record.content,
       bom: record.bom,
       originalEnding,
+      ...(record.separators !== undefined ? { separators: record.separators as LineEnding[] } : {}),
       hashes: record.hashes,
       resultContent: record.resultContent,
+      ...(record.resultSeparators !== undefined ? { resultSeparators: record.resultSeparators as LineEnding[] } : {}),
       ...(record.mode !== undefined ? { mode: record.mode } : {}),
     };
   } catch (error) {
@@ -171,7 +178,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
           if (
             currentRaw !== undefined &&
-            currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
+            currentRaw !== undo.bom + (undo.resultSeparators !== undefined ? joinSeparators(undo.resultContent, undo.resultSeparators) : restoreEndings(undo.resultContent, undo.originalEnding))
           ) {
             return {
               content: [
@@ -187,7 +194,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
           await writeAtomic(
             mutationTargetPath,
-            undo.bom + restoreEndings(undo.content, undo.originalEnding),
+            undo.bom + (undo.separators !== undefined ? joinSeparators(undo.content, undo.separators) : restoreEndings(undo.content, undo.originalEnding)),
             currentIdentity,
             undo.mode ?? fallbackFileMode(),
           );

package/src/replace.ts

@@ -10,7 +10,7 @@ import {
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { splitLines } from "./utils";
+import { literalEscapeWarning, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
 import { applyEdit,
@@ -21,6 +21,7 @@ import { applyEdit,
   AnchorMismatchError,
   type HEdit,
   type NEdit,
+  type StripWarningLocation,
 } from "./hashline";
 import { type RMetrics } from "./replace-response";
 import {
@@ -56,6 +57,7 @@ export interface PipelineResult {
   result: string;
   bom: string;
   originalEnding: LineEnding;
+  originalSeparators: LineEnding[];
   hadUtf8DecodeErrors: boolean;
   warnings: string[];
   noopEdit?: NEdit;
@@ -67,6 +69,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   identity: FileIdentity;
   spans?: DiffSpan[];
+  contentSeparators?: (LineEnding | undefined)[];
 }
 
 
@@ -76,6 +79,9 @@ export interface ExecPipelineOptions {
   store?: HashStore;
   noPersist?: boolean;
   preloadedNorm?: NormFile;
+  served?: ReadonlyMap<string, string>;
+  allowEmpty?: boolean;
+  stripWarning?: StripWarningLocation;
 }
 
 export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
@@ -91,7 +97,7 @@ export function spanForEdit(originalHashes: string[], from: string, to: string,
   const replacementCount = splitLines(resultContent).length - (originalHashes.length - (span[1] - span[0] + 1));
   return { start: span[0], end: span[1], replacementCount };
 }
-async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
+export async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
   if (error instanceof RangeStaleError) {
     adoptAnchors(absolutePath, error.rangeServedMap);
@@ -137,8 +143,8 @@ export async function execPipeline(
   const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
-  const served = servedForPath(preResolvedPath);
-  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
+  const served = options?.served ?? servedForPath(preResolvedPath);
+  const { normalized: originalNormalized, bom, originalEnding, endingSeparators: originalSeparators, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
     targetPath, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, allocation: options?.noPersist ? "shadow" : "real", preloadedNorm: options?.preloadedNorm },
   );
   const displayPath = toDisplayPath(cwd, absolutePath, targetPath);
@@ -152,6 +158,8 @@ export async function execPipeline(
       originalHashes,
       displayPath,
       served,
+      options?.allowEmpty,
+      options?.stripWarning,
     );
   } catch (error) {
     await noteAnchorError(absolutePath, error, options?.noPersist);
@@ -181,6 +189,7 @@ export async function execPipeline(
     result,
     bom,
     originalEnding,
+    originalSeparators,
     hadUtf8DecodeErrors,
     warnings,
     noopEdit: anchorResult.noopEdit,
@@ -192,6 +201,7 @@ export async function execPipeline(
     totalRemovedLines,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
+    ...(edit.content_separators !== undefined ? { contentSeparators: edit.content_separators } : {}),
   };
 }
 
@@ -263,6 +273,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         const canonical = normReq(params);
         assertReq(canonical);
         const normalizedParams = canonical;
+        const literalEscape = literalEscapeWarning(normalizedParams.replacement_lines, "replacement_lines");
         const targetPath = await resolveEditTargetWithRequirement({
           removeFrom: normalizedParams.remove_from,
           removeTo: normalizedParams.remove_to,
@@ -287,6 +298,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
               absolutePath,
               mutationTargetPath,
               editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+              prefixWarnings: literalEscape !== undefined ? [literalEscape] : [],
               signal,
             });
           }
@@ -305,7 +317,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
             cwd: ctx.cwd,
             signal,
             hedit: built.edit,
-            extraWarnings: built.warnings,
+            extraWarnings: [...(literalEscape !== undefined ? [literalEscape] : []), ...built.warnings],
           });
         });
       });

package/src/utils.ts

@@ -342,10 +342,6 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	return undefined;
 }
 
-function splitEditLines(text: string): string[] {
-	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-}
-
 function normalizeLineFieldValue(value: unknown): string[] | undefined {
 	const candidate = typeof value === "string"
 		? value
@@ -356,7 +352,7 @@ function normalizeLineFieldValue(value: unknown): string[] | undefined {
 	const decoded = decodeStringArray(candidate);
 	if (decoded !== undefined) return decoded;
 	if (/^\[\s*\]$/.test(stripTrailingMemberCall(stripCodeFence(candidate)))) return [];
-	return splitEditLines(candidate);
+	return [candidate];
 }
 
 function normalizeEditLines(record: Record<string, unknown>): void {
@@ -366,3 +362,42 @@ function normalizeEditLines(record: Record<string, unknown>): void {
 		if (lines !== undefined) record[key] = lines;
 	}
 }
+
+const LITERAL_ESCAPE_RE = /\\(?:u([0-9a-fA-F]{4})|([ntr"]))/g;
+
+const REAL_LINE_BREAK_RE = /[\n\r]/;
+
+function isSurrogateEscapePair(line: string, index: number, hex: string): boolean {
+	const code = Number.parseInt(hex, 16);
+	if (code >= 0xd800 && code <= 0xdbff) {
+		const next = /^\\u([0-9a-fA-F]{4})/.exec(line.slice(index + 6))?.[1];
+		if (next === undefined) return false;
+		const nextCode = Number.parseInt(next, 16);
+		return nextCode >= 0xdc00 && nextCode <= 0xdfff;
+	}
+	if (code >= 0xdc00 && code <= 0xdfff) {
+		const previous = /\\u([0-9a-fA-F]{4})$/.exec(line.slice(0, index))?.[1];
+		if (previous === undefined) return false;
+		const previousCode = Number.parseInt(previous, 16);
+		return previousCode >= 0xd800 && previousCode <= 0xdbff;
+	}
+	return false;
+}
+
+export function literalEscapeWarning(lines: string[], label: string): string | undefined {
+	for (const line of lines) {
+		if (!line.includes("\\")) continue;
+		const hasRealBreak = REAL_LINE_BREAK_RE.test(line);
+		for (const match of line.matchAll(LITERAL_ESCAPE_RE)) {
+			const hex = match[1];
+			const simple = match[2];
+			if (simple !== undefined && hasRealBreak) continue;
+			if (hex !== undefined) {
+				if (hex.toLowerCase() === "dddd") continue;
+				if (isSurrogateEscapePair(line, match.index, hex)) continue;
+			}
+			return `[W_LITERAL_ESCAPE] "${label}" contains the literal escape text "${match[0]}"`;
+		}
+	}
+	return undefined;
+}