pi-supernova 0.0.11 → 0.1.0

package/parallel.js

@@ -1,47 +1,55 @@
+import { isFunction } from "./decode.js";
 
-import { isString } from "./decode.js";
-export function isMutatingTool(name, config) {
-  const exact = new Set(config.mutatingTools || []);
-  if (exact.has(name)) return true;
-  const prefixes = config.mutatingPrefixes || [];
-  for (const prefix of prefixes) {
-    if (isString(prefix) && prefix.length > 0 && name.startsWith(prefix)) return true;
+const READ_ONLY_TOOLS = new Set(["read", "grep", "glob", "find", "ls", "snap", "evidence", "surface", "asgrep_search", "asgrep_status", "ast_grep", "web_search"]);
+const READ_ONLY_LSP = new Set(["definition", "references", "hover", "symbols", "diagnostics", "implementation", "type_definition", "incoming_calls", "outgoing_calls"]);
+
+export function isMutatingTool(name, config = {}, args = {}, definition) {
+  if ((config.mutatingTools ?? []).includes(name)) return true;
+  if ((config.mutatingPrefixes ?? []).some(prefix => prefix && name.startsWith(prefix))) return true;
+  if (definition?.annotations?.readOnlyHint === true) return false;
+  if (name === "lsp") {
+    const action = args.action ?? args.operation;
+    if (READ_ONLY_LSP.has(action)) return false;
+    if (["rename", "rename_file"].includes(action)) return args.apply !== false;
+    if (action === "code_actions") return args.apply === true;
+    return true;
   }
-  return false;
-}
-async function runSerial(list) {
-  const out = [];
-  for (const thunk of list) out.push(await thunk());
-  return out;
+  if (name === "todo") return args.op !== "view";
+  if (name === "hub") return !["list", "ps", "logs", "describe"].includes(args.op);
+  return !READ_ONLY_TOOLS.has(name);
 }
-function shouldParallelize(mode, anyMutating, count) {
-  if (mode === "parallel") return true;
-  if (mode !== "auto") return false;
-  if (anyMutating) return false;
-  return count > 1;
+
+function requireArray(value, name) {
+  if (!Array.isArray(value)) throw new TypeError(name + " requires an array");
+  return value;
 }
+
 export async function runParallelWave(thunks, meta, options = {}) {
-  const list = Array.isArray(thunks) ? thunks : [];
-  if (list.length === 0) return { results: [], mode: "serial", reason: "empty" };
+  const list = requireArray(thunks, "parallel wave");
+  if (list.some(item => !isFunction(item))) throw new TypeError("parallel wave requires functions");
+  if (!list.length) return { results: [], mode: "serial", reason: "empty" };
   const { mode = "auto", config = {} } = options;
-  const names = Array.isArray(meta?.names) ? meta.names : [];
-  const anyMutating = names.some((n) => isString(n) && isMutatingTool(n, config));
-  if (shouldParallelize(mode, anyMutating, list.length)) {
-    const results = await Promise.all(list.map((thunk) => thunk()));
-    return { results, mode: "parallel", reason: "independent-reads" };
+  const names = meta?.names ?? [];
+  const mutating = names.length !== list.length || names.some((name, i) => isMutatingTool(name, config, meta?.calls?.[i]?.args, meta?.definitions?.[i]));
+  if (!mutating && (mode === "parallel" || (mode === "auto" && list.length > 1))) {
+    // Do not finish a wave while its already-started host calls are still running.
+    const settled = await Promise.allSettled(list.map(thunk => Promise.resolve().then(thunk)));
+    const failure = settled.find(item => item.status === "rejected");
+    if (failure) throw failure.reason;
+    return { results: settled.map(item => item.value), mode: "parallel", reason: "independent-reads" };
   }
-  const results = await runSerial(list);
-  if (anyMutating) return { results, mode: "serial", reason: "mutating" };
-  return { results, mode: "serial", reason: "single-or-forced" };
+  const results = [];
+  for (const thunk of list) results.push(await thunk());
+  return { results, mode: "serial", reason: mutating ? "mutating" : "single-or-forced" };
 }
+
 export async function parallel(items) {
-  const list = Array.isArray(items) ? items : [];
-  return Promise.all(list.map((item) => (item instanceof Function ? item() : item)));
+  return Promise.all(requireArray(items, "parallel").map(item => isFunction(item) ? item() : item));
 }
+
 export async function pipeline(items, ...stages) {
-  let current = Array.isArray(items) ? items.slice() : [];
-  for (const stage of stages) {
-    current = await Promise.all(current.map((item) => stage(item)));
-  }
+  let current = requireArray(items, "pipeline");
+  if (stages.some(stage => !isFunction(stage))) throw new TypeError("pipeline stages must be functions");
+  for (const stage of stages) current = await Promise.all(current.map(item => stage(item)));
   return current;
 }

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,163 +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 — undercount ⇒ 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;
+  return stringWidth(String(text ?? "").replace(/\t/g, "   "));
 }
 
-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;
+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 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 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);
 }
 
-/**
- * Wrap plain text to width, preferring breaks after `/` or space so paths stay readable.
- * Every returned chunk is ≤ width (no ellipsis — caller clamps if needed).
- */
-export function wrapPlainToWidth(plain, width) {
-	const w = Math.max(1, width | 0);
-	const text = String(plain ?? "");
-	if (text.length === 0) return [""];
-	if (measureWidth(text) <= w) return [text];
-	const lines = [];
-	let i = 0;
-	while (i < text.length) {
-		const { end, lastBreak } = takeChunk(text, i, w);
-		if (end === i) {
-			const ch = text.codePointAt(i) > 0xffff ? text.slice(i, i + 2) : text[i];
-			lines.push(hardTruncate(ch, w));
-			i += ch.length;
-			continue;
-		}
-		let cut = end;
-		if (end < text.length && lastBreak > i + Math.floor(w * 0.35)) cut = lastBreak;
-		lines.push(text.slice(i, cut));
-		i = cut;
-	}
-	return lines;
+/** 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;
 }
 
-/**
- * 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);
+  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);
 }
-
-export { ELLIPSIS };