@ladbabynpm/picc-edit 0.1.0

package/src/file.ts

@@ -0,0 +1,162 @@
+// =============================================================================
+// picc-edit — src/file.ts
+//
+// Adaptors vs upstream:
+//   - `getFsImplementation()` → plain `node:fs`.
+//   - `safeResolvePath` is dropped (the caller passes an absolute path).
+//   - `writeFileSyncAndFlush_DEPRECATED` → `fs.writeFileSync`.
+// =============================================================================
+
+import {
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import {
+  basename,
+  dirname,
+  extname,
+  join,
+} from "node:path";
+
+export type LineEndingType = "CRLF" | "LF";
+
+function isEnoent(e: unknown): boolean {
+  return (
+    typeof e === "object" &&
+    e !== null &&
+    (e as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+/**
+ * Get the normalized modification time of a file in milliseconds.
+ */
+export function getFileModificationTime(filePath: string): number {
+  return Math.floor(statSync(filePath).mtimeMs);
+}
+
+/**
+ * Detect the file encoding from its leading bytes. Empty files default to
+ * utf8 so that writing emoji/CJK to empty files is not corrupted.
+ */
+export function detectEncodingForResolvedPath(
+  resolvedPath: string,
+): BufferEncoding {
+  const buffer = readFileSync(resolvedPath);
+  const bytesRead = buffer.length;
+
+  if (bytesRead === 0) {
+    return "utf8";
+  }
+
+  if (bytesRead >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+    return "utf16le";
+  }
+
+  if (
+    bytesRead >= 3 &&
+    buffer[0] === 0xef &&
+    buffer[1] === 0xbb &&
+    buffer[2] === 0xbf
+  ) {
+    return "utf8";
+  }
+
+  return "utf8";
+}
+
+/** Detect the dominant line-ending style in a string. */
+export function detectLineEndingsForString(content: string): LineEndingType {
+  let crlfCount = 0;
+  let lfCount = 0;
+
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      if (i > 0 && content[i - 1] === "\r") {
+        crlfCount++;
+      } else {
+        lfCount++;
+      }
+    }
+  }
+
+  return crlfCount > lfCount ? "CRLF" : "LF";
+}
+
+/**
+ * Read a file, returning its CRLF-normalized content plus detected encoding
+ * and line-ending style in one pass.
+ */
+export function readFileSyncWithMetadata(filePath: string): {
+  content: string;
+  encoding: BufferEncoding;
+  lineEndings: LineEndingType;
+} {
+  const encoding = detectEncodingForResolvedPath(filePath);
+  const raw = readFileSync(filePath, { encoding });
+  const lineEndings = detectLineEndingsForString(raw.slice(0, 4096));
+  return {
+    content: raw.replaceAll("\r\n", "\n"),
+    encoding,
+    lineEndings,
+  };
+}
+
+/**
+ * Write `content` to `filePath` with `endings` normalization applied.
+ *
+ * - `'LF'`: writes `content` verbatim (the model's sent line endings are
+ *   respected as-is; no resampling of the repo).
+ * - `'CRLF'`: normalizes any existing CRLF to LF first, then re-joins with
+ *   CRLF so a `content` that already contains `\r\n` does not become `\r\r\n`.
+ */
+export function writeTextContent(
+  filePath: string,
+  content: string,
+  encoding: BufferEncoding,
+  endings: LineEndingType,
+): void {
+  let toWrite = content;
+  if (endings === "CRLF") {
+    toWrite = content.replaceAll("\r\n", "\n").split("\n").join("\r\n");
+  }
+  writeFileSync(filePath, toWrite, { encoding });
+}
+
+/**
+ * Convert leading tabs on each line to two spaces. Used only for the
+ * *display* patch — the written content is left untouched.
+ */
+export function convertLeadingTabsToSpaces(content: string): string {
+  if (!content.includes("\t")) return content;
+  return content.replace(/^\t+/gm, (m) => "  ".repeat(m.length));
+}
+
+/**
+ * Find files with the same base name but a different extension in the same
+ * directory, to suggest a fix for a file-not-found edit. Returns the bare
+ * filename of the first match, or undefined.
+ */
+export function findSimilarFile(filePath: string): string | undefined {
+  try {
+    const dir = dirname(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+
+    const files = readdirSync(dir);
+    const similarFiles = files.filter(
+      (file) =>
+        basename(file, extname(file)) === fileBaseName &&
+        join(dir, file) !== filePath,
+    );
+
+    const firstMatch = similarFiles[0];
+    return firstMatch ? firstMatch : undefined;
+  } catch (error) {
+    if (!isEnoent(error)) {
+      throw error;
+    }
+    return undefined;
+  }
+}

package/src/path.ts

@@ -0,0 +1,62 @@
+// =============================================================================
+// picc-write — src/path.ts
+//
+// Adaptors vs upstream:
+//   - `getCwd()` / `getFsImplementation().cwd()` → `process.cwd()`
+//   - `getPlatform()` → `process.platform`
+// =============================================================================
+
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize, resolve } from "node:path";
+import { posixPathToWindowsPath } from "./windowsPaths.js";
+
+/**
+ * Expand `~` to the home directory, convert Windows POSIX-style paths, and
+ * resolve relative paths against `baseDir`.
+ *
+ * Ported from `utils/path.ts:expandPath`.
+ */
+export function expandPath(path: string, baseDir?: string): string {
+  const actualBaseDir = baseDir ?? process.cwd();
+
+  if (typeof path !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof path}`);
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(
+      `Base directory must be a string, received ${typeof actualBaseDir}`,
+    );
+  }
+
+  if (path.includes("\0") || actualBaseDir.includes("\0")) {
+    throw new Error("Path contains null bytes");
+  }
+
+  const trimmedPath = path.trim();
+  if (!trimmedPath) {
+    return normalize(actualBaseDir).normalize("NFC");
+  }
+
+  if (trimmedPath === "~") {
+    return homedir().normalize("NFC");
+  }
+
+  if (trimmedPath.startsWith("~/")) {
+    return join(homedir(), trimmedPath.slice(2)).normalize("NFC");
+  }
+
+  let processedPath = trimmedPath;
+  if (process.platform === "win32" && trimmedPath.match(/^\/[a-z]\//i)) {
+    try {
+      processedPath = posixPathToWindowsPath(trimmedPath);
+    } catch {
+      processedPath = trimmedPath;
+    }
+  }
+
+  if (isAbsolute(processedPath)) {
+    return normalize(processedPath).normalize("NFC");
+  }
+
+  return resolve(actualBaseDir, processedPath).normalize("NFC");
+}

package/src/prompt.ts

@@ -0,0 +1,39 @@
+// =============================================================================
+// picc-edit — src/prompt.ts
+//
+// Adaptors vs upstream:
+//   - `isCompactLinePrefixEnabled()` is hardcoded to `true` (picc-read always
+//     uses the compact `line-number + tab` prefix).
+//   - The `USER_TYPE === 'ant'` minimal-uniqueness hint is dropped.
+//   - `FILE_READ_TOOL_NAME` is fixed to `Read` (the read tool is configured
+//     independently of this extension).
+// =============================================================================
+
+function getPreReadInstruction(): string {
+  return `\n- You must use your \`read\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. `;
+}
+
+export function getEditToolDescription(): string {
+  return getDefaultEditDescription();
+}
+
+function getDefaultEditDescription(): string {
+  const prefixFormat = "line number + tab";
+  return `Performs exact string replacements in files.
+
+Usage:${getPreReadInstruction()}
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: ${prefixFormat}. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
+}
+
+/** Faithful success messages (from Claude Code's `mapToolResultToToolResultBlockParam`). */
+export function replaceAllMessage(filePath: string): string {
+  return `The file ${filePath} has been updated. All occurrences were successfully replaced.`;
+}
+
+export function singleEditMessage(filePath: string): string {
+  return `The file ${filePath} has been updated successfully.`;
+}

package/src/readState.ts

@@ -0,0 +1,52 @@
+// =============================================================================
+// picc-edit — src/readState.ts
+//
+// Session-scoped "has this file been read (and when)" map, mirroring Claude
+// Code's `readFileState`. pi has no shared read-state, so each of picc-write
+// and picc-edit owns its own: the entry point populates it from `tool_result`
+// events for any file tool that establishes known contents (read/write/edit)
+// and clears it on session start.
+// =============================================================================
+
+/** A recorded read of a file. `offset`/`limit` present ⇒ partial view. */
+export type ReadEntry = {
+  content: string;
+  timestamp: number;
+  offset?: number;
+  limit?: number;
+};
+
+/**
+ * Tool names whose successful `tool_result` means the file's contents are
+ * known and can seed the read-state. Mirrors Claude Code, where Read, Write,
+ * and Edit each refresh the shared `readFileState` — so a file the agent just
+ * wrote (or edited) is immediately editable/writable without a redundant
+ * re-read. Both pi's lowercase built-ins and the capitalized picc ports are
+ * accepted, since the active name depends on each extension's config.
+ */
+const KNOWN_FILE_TOOL_NAMES = new Set([
+  "read",
+  "Read",
+  "write",
+  "Write",
+  "edit",
+  "Edit",
+]);
+
+export function fileStateToolName(name: string): boolean {
+  return KNOWN_FILE_TOOL_NAMES.has(name);
+}
+
+const state = new Map<string, ReadEntry>();
+
+export function readStateGet(filePath: string): ReadEntry | undefined {
+  return state.get(filePath);
+}
+
+export function readStateSet(filePath: string, entry: ReadEntry): void {
+  state.set(filePath, entry);
+}
+
+export function readStateClear(): void {
+  state.clear();
+}

package/src/renderDiff.ts

@@ -0,0 +1,185 @@
+// =============================================================================
+// picc-edit — src/renderDiff.ts
+//
+// Local port of pi's built-in `renderDiff`
+// (`modes/interactive/components/diff.js`) with one difference: added lines
+// are drawn in a fixed truecolor green (#207c36) instead of the theme's
+// `toolDiffAdded` color (see `renderAddedLine`). Everything else — line
+// parsing, tab replacement, intra-line word diff with inverse highlighting —
+// mirrors the built-in so the TUI output matches pi's standard diff viewer.
+// =============================================================================
+
+import { type Change, diffWords } from "diff";
+
+/** Fixed truecolor for newly added lines (overrides the theme color). */
+const ADDED_LINE_FG = "\x1b[38;2;32;124;54m";
+/** Reset only the foreground color — same convention as `Theme.fg`. */
+const FG_RESET = "\x1b[39m";
+
+type RenderDiffTheme = {
+	fg: (color: "toolDiffRemoved" | "toolDiffContext", text: string) => string;
+	inverse: (text: string) => string;
+};
+
+/** Render an added line in the fixed #207c36 color. */
+function renderAddedLine(line: string): string {
+	return `${ADDED_LINE_FG}${line}${FG_RESET}`;
+}
+
+/** Parse diff line to extract prefix, line number, and content.
+ * Format: "+123 content" or "-123 content" or " 123 content" or "     ..." */
+function parseDiffLine(line: string): {
+	prefix: string;
+	lineNum: string;
+	content: string;
+} | null {
+	const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+	if (!match) return null;
+	return { prefix: match[1], lineNum: match[2], content: match[3] };
+}
+
+/** Replace tabs with spaces for consistent rendering. */
+function replaceTabs(text: string): string {
+	return text.replace(/\t/g, "   ");
+}
+
+/**
+ * Compute word-level diff and render with inverse on changed parts.
+ * Removed parts use the theme's inverse; added parts use the theme's inverse
+ * wrapped in the fixed added-line color (the inverse flips fg/bg, so the
+ * inverse spans still read as the #207c36 swap).
+ */
+function renderIntraLineDiff(
+	oldContent: string,
+	newContent: string,
+	theme: RenderDiffTheme,
+): { removedLine: string; addedLine: string } {
+	const wordDiff: Change[] = diffWords(oldContent, newContent);
+	let removedLine = "";
+	let addedLine = "";
+	let isFirstRemoved = true;
+	let isFirstAdded = true;
+	for (const part of wordDiff) {
+		if (part.removed) {
+			let value = part.value;
+			// Strip leading whitespace from the first removed part
+			if (isFirstRemoved) {
+				const leadingWs = value.match(/^(\s*)/)?.[1] || "";
+				value = value.slice(leadingWs.length);
+				removedLine += leadingWs;
+				isFirstRemoved = false;
+			}
+			if (value) {
+				removedLine += theme.inverse(value);
+			}
+		} else if (part.added) {
+			let value = part.value;
+			// Strip leading whitespace from the first added part
+			if (isFirstAdded) {
+				const leadingWs = value.match(/^(\s*)/)?.[1] || "";
+				value = value.slice(leadingWs.length);
+				addedLine += leadingWs;
+				isFirstAdded = false;
+			}
+			if (value) {
+				addedLine += theme.inverse(value);
+			}
+		} else {
+			removedLine += part.value;
+			addedLine += part.value;
+		}
+	}
+	return { removedLine, addedLine };
+}
+
+/**
+ * Render a diff string with colored lines and intra-line change highlighting.
+ * - Context lines: dim/gray
+ * - Removed lines: red, with inverse on changed tokens
+ * - Added lines: fixed #207c36, with inverse on changed tokens
+ */
+export function renderDiff(
+	diffText: string,
+	theme: RenderDiffTheme,
+): string {
+	const lines = diffText.split("\n");
+	const result: string[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const parsed = parseDiffLine(line);
+		if (!parsed) {
+			result.push(theme.fg("toolDiffContext", line));
+			i++;
+			continue;
+		}
+		if (parsed.prefix === "-") {
+			// Collect consecutive removed lines
+			const removedLines: { lineNum: string; content: string }[] = [];
+			while (i < lines.length) {
+				const p = parseDiffLine(lines[i]);
+				if (p?.prefix !== "-") break;
+				removedLines.push({ lineNum: p.lineNum, content: p.content });
+				i++;
+			}
+			// Collect consecutive added lines
+			const addedLines: { lineNum: string; content: string }[] = [];
+			while (i < lines.length) {
+				const p = parseDiffLine(lines[i]);
+				if (p?.prefix !== "+") break;
+				addedLines.push({ lineNum: p.lineNum, content: p.content });
+				i++;
+			}
+			// Only do intra-line diffing when there's exactly one removed and
+			// one added line (indicating a single line modification).
+			// Otherwise, show lines as-is.
+			if (removedLines.length === 1 && addedLines.length === 1) {
+				const removed = removedLines[0];
+				const added = addedLines[0];
+				const { removedLine, addedLine } = renderIntraLineDiff(
+					replaceTabs(removed.content),
+					replaceTabs(added.content),
+					theme,
+				);
+				result.push(
+					theme.fg(
+						"toolDiffRemoved",
+						`-${removed.lineNum} ${removedLine}`,
+					),
+				);
+				result.push(renderAddedLine(`+${added.lineNum} ${addedLine}`));
+			} else {
+				// Show all removed lines first, then all added lines
+				for (const removed of removedLines) {
+					result.push(
+						theme.fg(
+							"toolDiffRemoved",
+							`-${removed.lineNum} ${replaceTabs(removed.content)}`,
+						),
+					);
+				}
+				for (const added of addedLines) {
+					result.push(
+						renderAddedLine(`+${added.lineNum} ${replaceTabs(added.content)}`),
+					);
+				}
+			}
+		} else if (parsed.prefix === "+") {
+			// Standalone added line
+			result.push(
+				renderAddedLine(`+${parsed.lineNum} ${replaceTabs(parsed.content)}`),
+			);
+			i++;
+		} else {
+			// Context line
+			result.push(
+				theme.fg(
+					"toolDiffContext",
+					` ${parsed.lineNum} ${replaceTabs(parsed.content)}`,
+				),
+			);
+			i++;
+		}
+	}
+	return result.join("\n");
+}

package/src/windowsPaths.ts

@@ -0,0 +1,31 @@
+// =============================================================================
+// picc-write — src/windowsPaths.ts
+//
+// On Windows, Git Bash (MSYS2) passes POSIX-style paths like `/c/Users/...`.
+// This module converts that to a real Windows path so file APIs work.
+// =============================================================================
+
+/** Convert a POSIX path to a Windows path using pure JS. */
+export function posixPathToWindowsPath(posixPath: string): string {
+  // Handle UNC paths: //server/share -> \\server\share
+  if (posixPath.startsWith("//")) {
+    return posixPath.replace(/\//g, "\\");
+  }
+  // Handle /cygdrive/c/... format
+  const cygdriveMatch = posixPath.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+  if (cygdriveMatch) {
+    const driveLetter = cygdriveMatch[1]!.toUpperCase();
+    const rest = posixPath
+      .slice(("/cygdrive/" + cygdriveMatch[1]).length);
+    return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+  }
+  // Handle /c/... format (MSYS2/Git Bash)
+  const driveMatch = posixPath.match(/^\/([A-Za-z])(\/|$)/);
+  if (driveMatch) {
+    const driveLetter = driveMatch[1]!.toUpperCase();
+    const rest = posixPath.slice(2);
+    return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+  }
+  // Already Windows or relative — just flip slashes
+  return posixPath.replace(/\//g, "\\");
+}