@aliou/pi-processes 0.10.8 → 0.11.0

package/extensions/shared/truncate.ts

@@ -1,5 +1,194 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
 
+/**
+ * Wrap text to `maxWidth` display cells, returning one string per row.
+ *
+ * Walks graphemes like `truncateToWidth`, expands tabs to 3-column stops,
+ * handles wide characters (never splits one across a row boundary), and
+ * carries open SGR state across wrapped chunks so colours survive wrapping.
+ *
+ * Each returned chunk is padded to its row width and closed with a reset if
+ * any SGR is left open, matching the contract of `truncateToWidth(_, _, "", true)`.
+ *
+ * When `contIndent` > 0, the first row wraps to `maxWidth` and every
+ * continuation row wraps to `maxWidth - contIndent` (the caller prepends the
+ * indent prefix to those rows). This mirrors `less` narrowing wrapped rows.
+ */
+export function wrapToWidth(
+  text: string,
+  maxWidth: number,
+  contIndent = 0,
+): string[] {
+  if (maxWidth <= 0) return [];
+  const contWidth = Math.max(1, maxWidth - contIndent);
+  if (text.length === 0) return [" ".repeat(maxWidth)];
+
+  if (isPrintableAscii(text)) {
+    const rows: string[] = [];
+    let rowWidth = maxWidth;
+    let index = 0;
+    while (index < text.length) {
+      const slice = text.slice(index, index + rowWidth);
+      rows.push(slice + " ".repeat(rowWidth - slice.length));
+      index += rowWidth;
+      rowWidth = contWidth; // continuation rows are narrower
+    }
+    return rows;
+  }
+
+  const hasAnsi = text.includes("\u001b");
+  const hasTabs = text.includes("\t");
+
+  if (!hasAnsi && !hasTabs) {
+    return wrapPlainGraphemes(text, maxWidth, contWidth);
+  }
+
+  return wrapWithAnsiAndTabs(text, maxWidth, contWidth);
+}
+
+function wrapPlainGraphemes(
+  text: string,
+  firstWidth: number,
+  contWidth: number,
+): string[] {
+  const rows: string[] = [];
+  let current = "";
+  let width = 0;
+  let rowWidth = firstWidth;
+
+  for (const { segment } of segmenter.segment(text)) {
+    const segmentWidth = visibleWidth(segment);
+    if (width + segmentWidth > rowWidth && current.length > 0) {
+      rows.push(current + " ".repeat(rowWidth - width));
+      current = "";
+      width = 0;
+      rowWidth = contWidth;
+    }
+    current += segment;
+    width += segmentWidth;
+  }
+
+  rows.push(current + " ".repeat(rowWidth - width));
+  return rows;
+}
+
+function wrapWithAnsiAndTabs(
+  text: string,
+  firstWidth: number,
+  contWidth: number,
+): string[] {
+  const ESCAPE = "\u001b";
+  const RESET = `${ESCAPE}[0m`;
+  const SGR_PATTERN = new RegExp(`${ESCAPE}\\[[0-9;:]*m`, "u");
+  const rows: string[] = [];
+  let current = "";
+  let width = 0;
+  let rowWidth = firstWidth;
+  let pendingAnsi = "";
+  /** SGR sequences seen so far that are still "open" (not reset). */
+  let openSgr = "";
+
+  const flushRow = () => {
+    const padded = current + " ".repeat(rowWidth - width);
+    // Close any open SGR so colour does not bleed into the padding or the
+    // next row. The continuation row will re-open it.
+    if (openSgr && !padded.trimEnd().endsWith(RESET)) {
+      rows.push(`${padded}${RESET}`);
+    } else {
+      rows.push(padded);
+    }
+    current = "";
+    width = 0;
+    rowWidth = contWidth;
+  };
+
+  let index = 0;
+  while (index < text.length) {
+    const ansi = readAnsiSequence(text, index);
+    if (ansi) {
+      pendingAnsi += ansi;
+      // Track SGR state: a reset clears open styles; any other SGR
+      // accumulates so we can re-emit it at the start of continuation rows.
+      if (SGR_PATTERN.test(ansi)) {
+        if (ansi === RESET) {
+          openSgr = "";
+        } else {
+          openSgr += ansi;
+        }
+      }
+      index += ansi.length;
+      continue;
+    }
+
+    if (text[index] === "\t") {
+      const tabWidth = 3;
+      if (width + tabWidth > rowWidth && current.length > 0) {
+        if (pendingAnsi) {
+          current += pendingAnsi;
+          pendingAnsi = "";
+        }
+        flushRow();
+        // Re-emit open SGR at the start of the continuation row.
+        if (openSgr) {
+          current = openSgr;
+        }
+      }
+      if (pendingAnsi) {
+        current += pendingAnsi;
+        pendingAnsi = "";
+      }
+      current += "   ";
+      width += tabWidth;
+      index++;
+      continue;
+    }
+
+    // Gather a run of non-ANSI, non-tab characters, then segment it.
+    let end = index;
+    while (end < text.length && text[end] !== "\t") {
+      const nextAnsi = readAnsiSequence(text, end);
+      if (nextAnsi) break;
+      end++;
+    }
+
+    for (const { segment } of segmenter.segment(text.slice(index, end))) {
+      const segmentWidth = visibleWidth(segment);
+      if (width + segmentWidth > rowWidth && current.length > 0) {
+        if (pendingAnsi) {
+          current += pendingAnsi;
+          pendingAnsi = "";
+        }
+        flushRow();
+        // Re-emit open SGR at the start of the continuation row.
+        if (openSgr) {
+          current = openSgr;
+        }
+      }
+      if (pendingAnsi) {
+        current += pendingAnsi;
+        pendingAnsi = "";
+      }
+      current += segment;
+      width += segmentWidth;
+    }
+
+    index = end;
+  }
+
+  // Flush the final row.
+  if (pendingAnsi) {
+    current += pendingAnsi;
+  }
+  const padded = current + " ".repeat(rowWidth - width);
+  if (openSgr && !padded.trimEnd().endsWith(RESET)) {
+    rows.push(`${padded}${RESET}`);
+  } else {
+    rows.push(padded);
+  }
+
+  return rows;
+}
+
 export function truncateToWidth(
   text: string,
   maxWidth: number,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.10.8",
+  "version": "0.11.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -45,7 +45,7 @@
   "dependencies": {
     "@aliou/pi-utils-settings": "^0.19.1",
     "@aliou/pi-utils-ui": "^0.5.0",
-    "@aliou/sh": "^0.1.0"
+    "@aliou/sh": "^0.2.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
@@ -54,8 +54,8 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@aliou/biome-plugins": "^0.8.1",
-    "@biomejs/biome": "^2.4.15",
+    "@aliou/biome-plugins": "^0.12.0",
+    "@biomejs/biome": "^2.5.8",
     "@changesets/cli": "^2.27.11",
     "@earendil-works/pi-ai": "0.84.1",
     "@earendil-works/pi-coding-agent": "0.84.1",

package/src/utils/command-executor.ts

@@ -44,6 +44,7 @@ export function spawnCommand(
   command: string,
   cwd: string,
   configuredShell?: string,
+  env: NodeJS.ProcessEnv = process.env,
 ): ChildProcess {
   const shellExecutable = resolveShellExecutable({
     configuredShell,
@@ -52,7 +53,7 @@ export function spawnCommand(
 
   return spawn(shellExecutable, ["-lc", command], {
     cwd,
-    env: process.env,
+    env,
     stdio: ["pipe", "pipe", "pipe"],
     detached: true,
   });

package/src/utils/shell-utils.ts

@@ -2,6 +2,7 @@
 
 import type {
   Command,
+  ParamExp,
   Program,
   SimpleCommand,
   Statement,
@@ -28,18 +29,57 @@ function partToString(part: WordPart): string {
     case "DblQuoted":
       return part.parts.map(partToString).join("");
     case "ParamExp":
-      return part.short
-        ? `$${part.param.value}`
-        : `\${${part.param.value}${part.op ?? ""}${part.value ? wordToString(part.value) : ""}}`;
+      return paramExpToString(part);
     case "CmdSubst":
       return "$(...)";
     case "ArithExp":
-      return `$((${part.expr}))`;
+      return "$((...))";
     case "ProcSubst":
       return `${part.op}(...)`;
+    case "BraceExp":
+      return `{${part.elems.map(wordToString).join(",")}}`;
+    case "ExtGlob":
+      return `${part.op}${part.pattern})`;
   }
 }
 
+/**
+ * Render a raw text representation of a ParamExp node (e.g. `$VAR`,
+ * `${VAR:-default}`, `${#ARR[@]}`). Close to surface syntax, intended
+ * for display and command-name detection rather than exact round-trips.
+ */
+function paramExpToString(part: ParamExp): string {
+  const name = part.param.value;
+  if (part.short) return `$${name}`;
+
+  const prefix = part.excl ? "!" : part.length ? "#" : "";
+  const index = part.index ? `[${wordToString(part.index)}]` : "";
+
+  let suffix = "";
+  if (part.slice) {
+    const length = part.slice.length
+      ? `:${wordToString(part.slice.length)}`
+      : "";
+    suffix = `:${wordToString(part.slice.offset)}${length}`;
+  } else if (part.replace) {
+    const delimiter = part.replace.all
+      ? "//"
+      : part.replace.prefix
+        ? "/#"
+        : part.replace.suffix
+          ? "/%"
+          : "/";
+    const replacement = part.replace.with
+      ? `/${wordToString(part.replace.with)}`
+      : "";
+    suffix = `${delimiter}${wordToString(part.replace.orig)}${replacement}`;
+  } else if (part.exp) {
+    suffix = `${part.exp.op}${part.exp.word ? wordToString(part.exp.word) : ""}`;
+  }
+
+  return `\${${prefix}${name}${index}${suffix}}`;
+}
+
 /**
  * Walk the AST and call `callback` for every SimpleCommand found at any
  * nesting depth. Returns early if callback returns `true`.

package/extensions/shared/output-payload.ts

@@ -1,28 +0,0 @@
-import type { ProcessesOutputChangedPayload } from "../../src/protocol";
-import { isRecord } from "../../src/utils/is-record";
-
-export function isOutputChangedPayload(
-  payload: unknown,
-): payload is ProcessesOutputChangedPayload {
-  return (
-    isRecord(payload) &&
-    typeof payload.id === "string" &&
-    (payload.appendedText === undefined ||
-      (Array.isArray(payload.appendedText) &&
-        payload.appendedText.every(isOutputLine))) &&
-    (payload.droppedLines === undefined ||
-      (typeof payload.droppedLines === "number" &&
-        Number.isSafeInteger(payload.droppedLines) &&
-        payload.droppedLines > 0))
-  );
-}
-
-function isOutputLine(
-  value: unknown,
-): value is { type: "stdout" | "stderr"; text: string } {
-  return (
-    isRecord(value) &&
-    (value.type === "stdout" || value.type === "stderr") &&
-    typeof value.text === "string"
-  );
-}

package/src/get-manager.ts

@@ -1,15 +0,0 @@
-import { ProcessManager } from "./manager";
-
-export interface ManagerOptions {
-  getConfiguredShellPath?: () => string | undefined;
-}
-
-/**
- * Create a ProcessManager for the current extension instance.
- * The extension owns shutdown and must call manager.killAll()/cleanup().
- */
-export function getManager(opts?: ManagerOptions): ProcessManager {
-  return new ProcessManager({
-    getConfiguredShellPath: opts?.getConfiguredShellPath,
-  });
-}

package/src/utils/is-record.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}