pi-supernova 0.0.15 → 0.1.0

package/patch.js

@@ -3,104 +3,94 @@ import { isString } from "./decode.js";
 function parseHunkHeader(line) {
   const match = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(line);
   if (!match) return null;
-  return {
-    oldStart: parseInt(match[1], 10),
-    oldLength: match[2] !== undefined ? parseInt(match[2], 10) : 1,
-    newStart: parseInt(match[3], 10),
-    newLength: match[4] !== undefined ? parseInt(match[4], 10) : 1,
-    lines: [],
-  };
-}
-
-function isHunkLine(line) {
-  return line.startsWith("+") || line.startsWith("-") || line.startsWith(" ");
+  return { oldStart: Number(match[1]), oldLength: match[2] === undefined ? 1 : Number(match[2]),
+    newStart: Number(match[3]), newLength: match[4] === undefined ? 1 : Number(match[4]), lines: [], noNewline: [] };
 }
 
 export function parsePatchHunks(patchText) {
-  const patchLines = patchText.replace(/\r\n/g, "\n").split("\n");
   const hunks = [];
-  let current = null;
-
-  for (const line of patchLines) {
+  let current;
+  let oldCount = 0;
+  let newCount = 0;
+  for (const line of patchText.split("\n")) {
     const header = parseHunkHeader(line);
     if (header) {
-      if (current) hunks.push(current);
       current = header;
-    } else if (current && isHunkLine(line)) {
+      hunks.push(current);
+      oldCount = 0;
+      newCount = 0;
+    } else if (current && line.startsWith("\")) {
+      if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
+      current.noNewline.push(current.lines.length - 1);
+    } else if (current && /^[+ -]/.test(line)) {
+      if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
+        throw new Error("apply_patch accepts one file at a time");
+      }
       current.lines.push(line);
+      if (line[0] !== "+") oldCount++;
+      if (line[0] !== "-") newCount++;
     }
   }
-  if (current) hunks.push(current);
-  if (hunks.length === 0) {
-    throw new Error("no valid patch hunks found (expected @@ -old,len +new,len @@)");
-  }
+  if (!hunks.length) throw new Error("no valid patch hunks found (expected @@ -old,len +new,len @@)");
   return hunks;
 }
 
-function findHunkMatch(fileLines, expectedOld, nominal) {
-  const matchAt = (idx) => {
-    if (idx < 0 || idx + expectedOld.length > fileLines.length) return false;
-    for (let j = 0; j < expectedOld.length; j++) {
-      if (fileLines[idx + j] !== expectedOld[j]) return false;
-    }
-    return true;
-  };
+function splitFile(text) {
+  if (!text) return [];
+  const chunks = text.split("\n");
+  const trailing = chunks.at(-1) === "";
+  if (trailing) chunks.pop();
+  return chunks.map((chunk, index) => {
+    const newline = index < chunks.length - 1 || trailing;
+    const crlf = newline && chunk.endsWith("\r");
+    return { text: crlf ? chunk.slice(0, -1) : chunk, ending: newline ? (crlf ? "\r\n" : "\n") : "" };
+  });
+}
 
+function findHunkMatch(fileLines, expectedOld, nominal) {
+  const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
+    && expectedOld.every((line, i) => fileLines[index + i].text === line);
   if (matchAt(nominal)) return nominal;
-  const maxDelta = Math.max(fileLines.length, 100);
-  for (let delta = 1; delta <= maxDelta; delta++) {
+  if (!expectedOld.length) return -1;
+  for (let delta = 1; delta <= Math.max(fileLines.length, 100); delta++) {
     if (matchAt(nominal + delta)) return nominal + delta;
     if (matchAt(nominal - delta)) return nominal - delta;
   }
   return -1;
 }
 
-function splitHunkLines(hunk) {
-  const expectedOld = [];
-  const newLines = [];
-  for (const hLine of hunk.lines) {
-    if (hLine.startsWith("-")) {
-      expectedOld.push(hLine.slice(1));
-    } else if (hLine.startsWith("+")) {
-      newLines.push(hLine.slice(1));
-    } else {
-      const val = hLine.startsWith(" ") ? hLine.slice(1) : "";
-      expectedOld.push(val);
-      newLines.push(val);
-    }
-  }
-  return { expectedOld, newLines };
-}
-
 export function applyPatchToText(originalText, patchText) {
-  if (!isString(patchText) || !patchText.trim()) {
-    throw new Error("apply_patch requires non-empty patch");
-  }
-
+  if (!isString(patchText) || !patchText.trim()) throw new Error("apply_patch requires non-empty patch");
   const hunks = parsePatchHunks(patchText);
-  let fileLines = originalText.replace(/\r\n/g, "\n").split("\n");
-  const hasTrailingNewline = originalText.endsWith("\n");
+  const fileLines = splitFile(originalText);
+  const ending = fileLines.find(line => line.ending)?.ending ?? "\n";
   let offsetShift = 0;
-
+  let relocationShift = 0;
   for (let h = 0; h < hunks.length; h++) {
     const hunk = hunks[h];
-    const { expectedOld, newLines } = splitHunkLines(hunk);
-
-    if (expectedOld.length !== hunk.oldLength || newLines.length !== hunk.newLength) {
-      throw new Error(`patch hunk ${h + 1} length does not match its header`);
-    }
-
-    const nominal = Math.max(0, hunk.oldStart - 1 + offsetShift);
-    const matchIdx = findHunkMatch(fileLines, expectedOld, nominal);
-    if (matchIdx === -1) {
-      throw new Error(`patch hunk ${h + 1} rejected at line ${hunk.oldStart}: context did not match`);
+    const textOf = line => line.slice(1).replace(/\r$/, "");
+    const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(textOf);
+    const newCount = hunk.lines.filter(line => line[0] !== "-").length;
+    if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
+    // The new coordinate also handles BSD diff's -1,0 header at file start.
+    const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
+    const matchIndex = findHunkMatch(fileLines, expectedOld, nominal);
+    if (matchIndex < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
+    const replacement = [];
+    let oldIndex = matchIndex;
+    for (let i = 0; i < hunk.lines.length; i++) {
+      const line = hunk.lines[i];
+      if (line[0] === "+") {
+        replacement.push({ text: textOf(line), ending: hunk.noNewline.includes(i) ? "" : line.endsWith("\r") ? "\r\n" : ending });
+      } else {
+        const original = fileLines[oldIndex++];
+        if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
+        if (line[0] === " ") replacement.push(original);
+      }
     }
-
-    fileLines.splice(matchIdx, expectedOld.length, ...newLines);
-    offsetShift += (matchIdx - nominal) + (newLines.length - expectedOld.length);
+    fileLines.splice(matchIndex, expectedOld.length, ...replacement);
+    relocationShift += matchIndex - nominal;
+    offsetShift += matchIndex - nominal + replacement.length - expectedOld.length;
   }
-
-  let resultText = fileLines.join("\n");
-  if (hasTrailingNewline && !resultText.endsWith("\n")) resultText += "\n";
-  return { resultText, hunkCount: hunks.length };
+  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length };
 }

package/render-measure.js

@@ -1,135 +1,65 @@
-/**
- * Width / truncate primitives used by the compact renderer.
- * Self-contained so path-install never depends on a host truncate that can
- * append ellipsis after cutting to maxWidth (Pi 92>91 crash class).
- */
-
 import { stripVTControlCharacters } from "node:util";
+import stringWidth from "string-width";
 
 const ELLIPSIS = "…";
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
-/**
- * Visible columns: ANSI/OSC stripped, tabs → 3 spaces.
- * ASCII-fast; non-ASCII uses a wide-char heuristic aligned with typical terminal
- * / pi-tui behavior (emoji & symbols like ⚡ are 2 cols; an undercount is the 92>91 crash).
- */
 export function measureWidth(text) {
-	const raw = String(text ?? "").replace(/\t/g, "   ");
-	if (raw.length === 0) return 0;
-	const plain = raw.includes("\x1b") ? stripVTControlCharacters(raw) : raw;
-	if (/^[\x20-\x7e]*$/.test(plain)) return plain.length;
-	let width = 0;
-	for (const ch of plain) {
-		width += codePointWidth(ch.codePointAt(0));
-	}
-	return width;
-}
-
-const ZERO_RANGES = [
-	[0x00, 0x1f],
-	[0x7f, 0x9f],
-	[0x0300, 0x036f],
-	[0x1ab0, 0x1aff],
-	[0x1dc0, 0x1dff],
-	[0x20d0, 0x20ff],
-	[0xfe00, 0xfe0e],
-	[0xfe20, 0xfe2f],
-];
-
-const WIDE_RANGES = [
-	[0x1100, 0x115f],
-	[0x2e80, 0xa4cf],
-	[0xac00, 0xd7a3],
-	[0xf900, 0xfaff],
-	[0xfe10, 0xfe19],
-	[0xfe30, 0xfe6f],
-	[0xff00, 0xff60],
-	[0xffe0, 0xffe6],
-	[0x1f000, 0x1faff],
-	[0x20000, 0x3fffd],
-];
-
-const WIDE_SINGLES = [0x2329, 0x232a, 0x26a1, 0x2b50, 0x2728];
-
-function inRanges(cp, ranges) {
-	for (const [lo, hi] of ranges) {
-		if (cp >= lo && cp <= hi) return true;
-	}
-	return false;
+  return stringWidth(String(text ?? "").replace(/\t/g, "   "));
 }
 
-function codePointWidth(cp) {
-	if (cp === 0xfe0f) return 1;
-	if (cp === 0x200d) return 0;
-	if (inRanges(cp, ZERO_RANGES)) return 0;
-	if (WIDE_SINGLES.includes(cp)) return 2;
-	if (inRanges(cp, WIDE_RANGES)) return 2;
-	return 1;
+function takePrefix(text, width) {
+  let end = 0;
+  let columns = 0;
+  for (const { segment, index } of segmenter.segment(text)) {
+    const next = measureWidth(segment);
+    if (columns + next > width) break;
+    columns += next;
+    end = index + segment.length;
+  }
+  return text.slice(0, end);
 }
 
-function takeChunk(text, start, width) {
-	let end = start;
-	let visible = 0;
-	let lastBreak = -1;
-	while (end < text.length) {
-		const cp = text.codePointAt(end);
-		const ch = cp > 0xffff ? text.slice(end, end + 2) : text[end];
-		const cw = measureWidth(ch);
-		if (visible + cw > width) break;
-		visible += cw;
-		end += ch.length;
-		if (ch === "/" || ch === " ") lastBreak = end;
-	}
-	return { end, lastBreak };
-}
-
-/**
- * Truncate so the result's visible width is ALWAYS ≤ maxWidth, ellipsis included.
- * Strips ANSI in the truncated region (crash-safety > color fidelity on overflow).
- */
 export function hardTruncate(text, maxWidth, ellipsis = ELLIPSIS) {
-	const w = Math.max(0, maxWidth | 0);
-	if (w === 0) return "";
-	const raw = String(text ?? "").replace(/\t/g, "   ");
-	if (measureWidth(raw) <= w) return raw;
-	const ell = String(ellipsis);
-	const ellW = measureWidth(ell);
-	if (ellW >= w) {
-		if (ellW === 0) return "";
-		return ell.slice(0, w);
-	}
-	const budget = w - ellW;
-	const plain = stripVTControlCharacters(raw);
-	const { end } = takeChunk(plain, 0, budget);
-	return plain.slice(0, end) + ell;
+  const width = Math.max(0, Math.floor(maxWidth));
+  if (!width) return "";
+  const raw = String(text ?? "").replace(/\t/g, "   ");
+  if (measureWidth(raw) <= width) return raw;
+  const suffix = stripVTControlCharacters(String(ellipsis));
+  const suffixWidth = measureWidth(suffix);
+  if (suffixWidth >= width) return takePrefix(suffix, width);
+  return takePrefix(stripVTControlCharacters(raw), width - suffixWidth) + suffix;
 }
 
-/**
- * Absolute clamp used by every renderer. Loops + hard truncate; never returns > width.
- */
 export function clampLine(line, width) {
-	const w = Math.max(1, width | 0);
-	let out = String(line ?? "").replace(/\t/g, "   ");
-	if (measureWidth(out) <= w) return out;
-	out = hardTruncate(out, w, ELLIPSIS);
-	if (measureWidth(out) <= w) return out;
-	const plain = stripVTControlCharacters(out);
-	if (plain.length <= w) return plain;
-	if (w === 1) return ELLIPSIS;
-	return plain.slice(0, Math.max(0, w - 1)) + ELLIPSIS;
+  return hardTruncate(line, width);
 }
 
-/**
- * Fit a filesystem path into `budget` columns, keeping the basename visible.
- */
-export function fitPath(pathText, budget) {
-	const w = Math.max(1, budget | 0);
-	let p = String(pathText ?? "").replace(/\\/g, "/");
-	if (measureWidth(p) <= w) return p;
-	const parts = p.split("/").filter(Boolean);
-	const base = parts.length > 0 ? parts[parts.length - 1] : p;
-	const suffix = parts.length > 1 ? `…/${base}` : base;
-	if (measureWidth(suffix) <= w) return suffix;
-	return hardTruncate(base, w);
+/** Wrap complete, already-sanitized result text without splitting graphemes. */
+export function wrapLine(line, width) {
+  if (width <= 0) return [];
+  const text = String(line).replace(/\t/g, "   ");
+  if (measureWidth(text) <= width) return [text];
+  const out = [];
+  let current = "";
+  let columns = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    const size = measureWidth(segment);
+    if (columns + size > width && current) { out.push(current); current = ""; columns = 0; }
+    if (size > width) { out.push(ELLIPSIS); continue; }
+    current += segment;
+    columns += size;
+  }
+  if (current) out.push(current);
+  return out;
 }
 
+export function fitPath(pathText, budget) {
+  const width = Math.max(0, Math.floor(budget));
+  const text = String(pathText ?? "").replace(/\\/g, "/");
+  if (measureWidth(text) <= width) return text;
+  const parts = text.split("/").filter(Boolean);
+  const base = parts.at(-1) ?? text;
+  const suffix = parts.length > 1 ? "…/" + base : base;
+  return measureWidth(suffix) <= width ? suffix : hardTruncate(base, width);
+}

package/render.js

@@ -12,7 +12,7 @@
 
 import { stripVTControlCharacters } from "node:util";
 import { isString, isObject, isFunction } from "./decode.js";
-import { measureWidth, hardTruncate, clampLine, fitPath } from "./render-measure.js";
+import { measureWidth, hardTruncate, clampLine, fitPath, wrapLine } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 import { formatValue } from "./format.js";
 
@@ -232,7 +232,6 @@ export function renderSupernovaCall(a, b, c) {
 
 const TOOL_COL = 7;
 const DURATION_COL = 6;
-const PREVIEW_LINES = 24;
 
 function formatDuration(ms) {
 	if (!Number.isFinite(ms) || ms < 0) return "";
@@ -310,12 +309,9 @@ function operationsFor(payload, context) {
 	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
 }
 
-function resultLines(value, maxLines) {
+function resultLines(value, width) {
 	const text = isString(value) ? value : formatValue(value);
-	const lines = cleanBlockText(text).split("\n");
-	const shown = lines.slice(0, maxLines);
-	if (lines.length > maxLines) shown.push(`… ${lines.length - maxLines} more lines`);
-	return shown;
+	return cleanBlockText(text).split("\n").flatMap(line => wrapLine(line, width));
 }
 
 function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError) {
@@ -327,15 +323,18 @@ function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, is
 	if (ops.length > maxOps) lines.push(theme.fg("dim", `  … ${ops.length - maxOps} more calls`));
 }
 
-function appendTail(lines, theme, payload, expanded, isError) {
-	if (isError) lines.push(theme.fg("error", "✗ " + (payload?.error ? cleanBlockText(payload.error) : "error")));
+function appendTail(lines, theme, payload, expanded, isError, width) {
+	if (isError) {
+		const error = "✗ " + (payload?.error ? cleanBlockText(payload.error) : "error");
+		for (const line of expanded ? resultLines(error, width) : error.split("\n")) lines.push(theme.fg("error", line));
+	}
 	else if (expanded && payload?.result !== undefined) {
 		lines.push(theme.fg("dim", "── result ──"));
-		for (const line of resultLines(payload.result, PREVIEW_LINES)) lines.push(theme.fg("toolOutput", line));
+		for (const line of resultLines(payload.result, width)) lines.push(theme.fg("toolOutput", line));
 	}
 	if (expanded && payload?.logs?.length) {
 		lines.push(theme.fg("dim", "── logs ──"));
-		for (const log of payload.logs.slice(0, PREVIEW_LINES)) lines.push(theme.fg("dim", cleanBlockText(log)));
+		for (const log of payload.logs) for (const line of resultLines(log, width)) lines.push(theme.fg("dim", line));
 	}
 }
 
@@ -345,7 +344,7 @@ function buildBodyLines(theme, width, { payload, context, args, expanded, isPart
 	const maxDiffLines = expanded ? 24 : 8;
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
-	appendTail(lines, theme, payload, expanded, isError);
+	appendTail(lines, theme, payload, expanded, isError, width);
 	return { lines, opCount: ops.length };
 }
 
@@ -367,7 +366,7 @@ class UnifiedResultCard {
 	}
 	render(width = 80) {
 		const { theme, model } = this;
-		if (!theme || !model) return [];
+		if (!theme || !model || width <= 0) return [];
 		if (this.cache?.width === width) return this.cache.lines;
 		const view = buildBodyLines(theme, Math.max(1, width - 4), model);
 		const header = novaStatusLine(theme, {

package/repo-index.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { extractStructuralSurface } from "./surface.js";
+import { isFunction } from "./decode.js";
 import { Frecency } from "./fuzzy.js";
 import { relativeSlash } from "./workspace.js";
 
@@ -112,7 +113,7 @@ export class WorkspaceIndex {
         this.watchers.set(root, false);
         this.lists.clear();
       });
-      if (typeof watcher.unref === "function") watcher.unref();
+      if (isFunction(watcher.unref)) watcher.unref();
       ok = true;
     } catch {
       ok = false;