@scelar/nodepod 1.0.0

package/src/shell/commands/text-processing.ts

@@ -0,0 +1,1152 @@
+import type { BuiltinFn, ShellContext } from "../shell-types";
+import {
+  ok,
+  fail,
+  EXIT_OK,
+  EXIT_FAIL,
+  resolvePath,
+  parseArgs,
+  processEscapes,
+  expandCharClass,
+  RESET,
+  GREEN,
+  MAGENTA,
+  CYAN,
+  BOLD_RED,
+} from "../shell-helpers";
+import { YES_REPEAT_COUNT } from "../../constants/config";
+
+/* ------------------------------------------------------------------ */
+/*  echo / printf                                                      */
+/* ------------------------------------------------------------------ */
+
+const echo: BuiltinFn = (args) => {
+  let noNewline = false;
+  let enableEscapes = false;
+  let start = 0;
+
+  while (start < args.length) {
+    const a = args[start];
+    if (a === "-n") {
+      noNewline = true;
+      start++;
+    } else if (a === "-e") {
+      enableEscapes = true;
+      start++;
+    } else if (a === "-E") {
+      enableEscapes = false;
+      start++;
+    } else if (a === "-ne" || a === "-en") {
+      noNewline = true;
+      enableEscapes = true;
+      start++;
+    } else if (a === "-nE" || a === "-En") {
+      noNewline = true;
+      start++;
+    } else break;
+  }
+
+  let output = args.slice(start).join(" ");
+  if (enableEscapes) output = processEscapes(output);
+  return ok(output + (noNewline ? "" : "\n"));
+};
+
+const printf_cmd: BuiltinFn = (args) => {
+  if (args.length === 0) return ok();
+  const fmt = args[0];
+  const vals = args.slice(1);
+  let out = "";
+  let vi = 0;
+
+  let i = 0;
+  while (i < fmt.length) {
+    if (fmt[i] === "\\" && i + 1 < fmt.length) {
+      const c = fmt[i + 1];
+      if (c === "n") { out += "\n"; i += 2; continue; }
+      if (c === "t") { out += "\t"; i += 2; continue; }
+      if (c === "r") { out += "\r"; i += 2; continue; }
+      if (c === "a") { out += "\x07"; i += 2; continue; }
+      if (c === "b") { out += "\b"; i += 2; continue; }
+      if (c === "f") { out += "\f"; i += 2; continue; }
+      if (c === "v") { out += "\x0b"; i += 2; continue; }
+      if (c === "\\") { out += "\\"; i += 2; continue; }
+      if (c === "0") {
+        let oct = "";
+        let j = i + 2;
+        while (j < fmt.length && j < i + 5 && fmt[j] >= "0" && fmt[j] <= "7")
+          oct += fmt[j++];
+        out += String.fromCharCode(parseInt(oct || "0", 8));
+        i = j;
+        continue;
+      }
+      if (c === "x") {
+        const hex = fmt.slice(i + 2, i + 4).match(/^[0-9a-fA-F]+/)?.[0] ?? "";
+        if (hex) {
+          out += String.fromCharCode(parseInt(hex, 16));
+          i += 2 + hex.length;
+          continue;
+        }
+      }
+      out += fmt[i];
+      i++;
+      continue;
+    }
+
+    if (fmt[i] === "%" && i + 1 < fmt.length) {
+      i++;
+      let fmtFlags = "";
+      while ("-+ 0#".includes(fmt[i])) fmtFlags += fmt[i++];
+      let width = "";
+      if (fmt[i] === "*") { width = vals[vi++] ?? "0"; i++; }
+      else { while (fmt[i] >= "0" && fmt[i] <= "9") width += fmt[i++]; }
+      let prec = "";
+      if (fmt[i] === ".") {
+        i++;
+        if (fmt[i] === "*") { prec = vals[vi++] ?? "0"; i++; }
+        else { while (fmt[i] >= "0" && fmt[i] <= "9") prec += fmt[i++]; }
+      }
+      const spec = fmt[i++];
+      const val = vals[vi++] ?? "";
+
+      if (spec === "%") { out += "%"; vi--; continue; }
+      if (spec === "s") {
+        let s = val;
+        if (prec) s = s.slice(0, parseInt(prec));
+        const w = parseInt(width) || 0;
+        if (fmtFlags.includes("-")) out += s.padEnd(w);
+        else out += s.padStart(w);
+        continue;
+      }
+      if (spec === "d" || spec === "i") {
+        const n = parseInt(val) || 0;
+        let s = (fmtFlags.includes("+") && n >= 0 ? "+" : "") + String(n);
+        if (fmtFlags.includes(" ") && n >= 0 && !fmtFlags.includes("+")) s = " " + s;
+        const w = parseInt(width) || 0;
+        const pad = fmtFlags.includes("0") && !fmtFlags.includes("-") ? "0" : " ";
+        if (fmtFlags.includes("-")) out += s.padEnd(w);
+        else if (pad === "0" && s[0] === "-") out += "-" + s.slice(1).padStart(w - 1, "0");
+        else out += s.padStart(w, pad);
+        continue;
+      }
+      if (spec === "f") {
+        const n = parseFloat(val) || 0;
+        const p = prec !== "" ? parseInt(prec) : 6;
+        let s = n.toFixed(p);
+        if (fmtFlags.includes("+") && n >= 0) s = "+" + s;
+        const w = parseInt(width) || 0;
+        if (fmtFlags.includes("-")) out += s.padEnd(w);
+        else out += s.padStart(w, fmtFlags.includes("0") ? "0" : " ");
+        continue;
+      }
+      if (spec === "x") {
+        const n = (parseInt(val) || 0) >>> 0;
+        let s = n.toString(16);
+        if (fmtFlags.includes("#") && n !== 0) s = "0x" + s;
+        out += s.padStart(parseInt(width) || 0, fmtFlags.includes("0") ? "0" : " ");
+        continue;
+      }
+      if (spec === "X") {
+        const n = (parseInt(val) || 0) >>> 0;
+        let s = n.toString(16).toUpperCase();
+        if (fmtFlags.includes("#") && n !== 0) s = "0X" + s;
+        out += s.padStart(parseInt(width) || 0, fmtFlags.includes("0") ? "0" : " ");
+        continue;
+      }
+      if (spec === "o") {
+        const n = (parseInt(val) || 0) >>> 0;
+        let s = n.toString(8);
+        if (fmtFlags.includes("#") && n !== 0) s = "0" + s;
+        out += s.padStart(parseInt(width) || 0, fmtFlags.includes("0") ? "0" : " ");
+        continue;
+      }
+      if (spec === "e" || spec === "E") {
+        const n = parseFloat(val) || 0;
+        const p = prec !== "" ? parseInt(prec) : 6;
+        let s = spec === "E" ? n.toExponential(p).toUpperCase() : n.toExponential(p);
+        if (fmtFlags.includes("+") && n >= 0) s = "+" + s;
+        out += s.padStart(parseInt(width) || 0);
+        continue;
+      }
+      if (spec === "g" || spec === "G") {
+        const n = parseFloat(val) || 0;
+        const p = prec !== "" ? parseInt(prec) : 6;
+        let s = spec === "G" ? n.toPrecision(p).toUpperCase() : n.toPrecision(p);
+        if (fmtFlags.includes("+") && n >= 0) s = "+" + s;
+        out += s.padStart(parseInt(width) || 0);
+        continue;
+      }
+      if (spec === "c") { out += val ? val[0] : ""; continue; }
+      out += "%" + spec;
+      vi--;
+      continue;
+    }
+    out += fmt[i++];
+  }
+  return ok(out);
+};
+
+/* ------------------------------------------------------------------ */
+/*  grep / egrep / fgrep                                               */
+/* ------------------------------------------------------------------ */
+
+interface GrepOpts {
+  regex: RegExp;
+  highlightRe: RegExp;
+  patternStr: string;
+  ignoreCase: boolean;
+  invert: boolean;
+  countOnly: boolean;
+  filesOnly: boolean;
+  lineNumbers: boolean;
+  onlyMatching: boolean;
+  quiet: boolean;
+  beforeCtx: number;
+  afterCtx: number;
+  maxCount: number;
+}
+
+function grepLines(content: string, opts: GrepOpts, label?: string): string {
+  const {
+    regex, highlightRe, patternStr, ignoreCase, invert,
+    countOnly, filesOnly, lineNumbers, onlyMatching, quiet,
+    beforeCtx, afterCtx, maxCount,
+  } = opts;
+  const lines = content.split("\n");
+  const matchedIndices = new Set<number>();
+  let matchCount = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (regex.test(lines[i]) !== invert) {
+      matchedIndices.add(i);
+      matchCount++;
+      if (matchCount >= maxCount) break;
+    }
+  }
+
+  if (countOnly) {
+    return (label ? `${MAGENTA}${label}${RESET}${CYAN}:${RESET}` : "") +
+      matchedIndices.size + "\n";
+  }
+  if (filesOnly && matchedIndices.size > 0) {
+    return `${MAGENTA}${label ?? ""}${RESET}\n`;
+  }
+  if (quiet) return matchedIndices.size > 0 ? "\0" : "";
+
+  const showLines = new Set<number>();
+  for (const idx of matchedIndices) {
+    for (
+      let j = Math.max(0, idx - beforeCtx);
+      j <= Math.min(lines.length - 1, idx + afterCtx);
+      j++
+    ) {
+      showLines.add(j);
+    }
+  }
+
+  let out = "";
+  let prevShown = -2;
+  for (let i = 0; i < lines.length; i++) {
+    if (!showLines.has(i)) continue;
+    if (
+      prevShown >= 0 &&
+      i > prevShown + 1 &&
+      (beforeCtx > 0 || afterCtx > 0)
+    ) {
+      out += "--\n";
+    }
+    prevShown = i;
+
+    const isMatch = matchedIndices.has(i);
+    const sep = isMatch ? `${CYAN}:${RESET}` : `${CYAN}-${RESET}`;
+    const prefix = label ? `${MAGENTA}${label}${RESET}${sep}` : "";
+    const num = lineNumbers ? `${GREEN}${i + 1}${RESET}${sep}` : "";
+
+    if (onlyMatching && isMatch && !invert) {
+      const gRe = new RegExp(patternStr, ignoreCase ? "gi" : "g");
+      let m: RegExpExecArray | null;
+      while ((m = gRe.exec(lines[i])) !== null) {
+        out += `${prefix}${num}${BOLD_RED}${m[0]}${RESET}\n`;
+      }
+    } else {
+      const hl =
+        isMatch && !invert
+          ? lines[i].replace(highlightRe, (m) => `${BOLD_RED}${m}${RESET}`)
+          : lines[i];
+      out += `${prefix}${num}${hl}\n`;
+    }
+  }
+
+  return out;
+}
+
+function grepDirFull(
+  ctx: ShellContext,
+  dir: string,
+  opts: GrepOpts,
+): string {
+  let out = "";
+  try {
+    for (const name of ctx.volume.readdirSync(dir)) {
+      const full = `${dir}/${name}`;
+      const st = ctx.volume.statSync(full);
+      if (st.isDirectory()) {
+        out += grepDirFull(ctx, full, opts);
+      } else {
+        try {
+          const content = ctx.volume.readFileSync(full, "utf8");
+          out += grepLines(content, opts, full);
+        } catch {
+          /* skip binary/unreadable */
+        }
+      }
+    }
+  } catch {
+    /* skip unreadable dirs */
+  }
+  return out;
+}
+
+const grep_cmd: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, opts: parsedOpts, positional } = parseArgs(
+    args,
+    [
+      "i", "v", "c", "l", "n", "r", "R", "o", "w", "x",
+      "E", "F", "P", "H", "h", "q", "s", "z",
+    ],
+    ["A", "B", "C", "m", "e", "f"],
+  );
+  const ignoreCase = flags.has("i");
+  const invert = flags.has("v");
+  const countOnly = flags.has("c");
+  const filesOnly = flags.has("l");
+  const lineNumbers = flags.has("n");
+  const recursive = flags.has("r") || flags.has("R");
+  const onlyMatching = flags.has("o");
+  const wordRegex = flags.has("w");
+  const lineRegex = flags.has("x");
+  const fixedStrings = flags.has("F");
+  const quiet = flags.has("q");
+  const suppressErrors = flags.has("s");
+  const afterCtx = parseInt(parsedOpts["A"] || parsedOpts["C"] || "0");
+  const beforeCtx = parseInt(parsedOpts["B"] || parsedOpts["C"] || "0");
+  const maxCount = parsedOpts["m"] ? parseInt(parsedOpts["m"]) : Infinity;
+
+  let patternStr: string;
+  if (parsedOpts["e"] !== undefined) {
+    patternStr = parsedOpts["e"];
+  } else if (positional.length === 0) {
+    return fail("grep: missing pattern\n");
+  } else {
+    patternStr = positional.shift()!;
+  }
+
+  if (fixedStrings)
+    patternStr = patternStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (wordRegex) patternStr = `\\b${patternStr}\\b`;
+  if (lineRegex) patternStr = `^${patternStr}$`;
+
+  let regex: RegExp;
+  let highlightRe: RegExp;
+  try {
+    regex = new RegExp(patternStr, ignoreCase ? "im" : "m");
+    highlightRe = new RegExp(patternStr, ignoreCase ? "gi" : "g");
+  } catch {
+    return fail(`grep: Invalid regular expression: '${patternStr}'\n`);
+  }
+
+  const grepOpts: GrepOpts = {
+    regex, highlightRe, patternStr, ignoreCase, invert,
+    countOnly, filesOnly, lineNumbers, onlyMatching, quiet,
+    beforeCtx, afterCtx, maxCount,
+  };
+
+  const files = positional;
+
+  if (files.length === 0 && stdin !== undefined) {
+    const result = grepLines(stdin, grepOpts);
+    if (quiet) return result ? EXIT_OK : EXIT_FAIL;
+    return result ? ok(result) : EXIT_FAIL;
+  }
+
+  if (files.length === 0) {
+    return fail("grep: missing file operand\n");
+  }
+
+  let out = "";
+  const multiFile = files.length > 1 || recursive;
+  let anyMatch = false;
+
+  for (const file of files) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const st = ctx.volume.statSync(p);
+      if (st.isDirectory()) {
+        if (recursive) {
+          const r = grepDirFull(ctx, p, grepOpts);
+          out += r;
+          if (r) anyMatch = true;
+        } else if (!suppressErrors) {
+          out += `grep: ${file}: Is a directory\n`;
+        }
+        continue;
+      }
+      const content = ctx.volume.readFileSync(p, "utf8");
+      const result = grepLines(content, grepOpts, multiFile ? file : undefined);
+      out += result;
+      if (result) anyMatch = true;
+    } catch {
+      if (!suppressErrors)
+        return fail(`grep: ${file}: No such file or directory\n`);
+    }
+  }
+
+  if (quiet) return anyMatch ? EXIT_OK : EXIT_FAIL;
+  return anyMatch ? ok(out) : { stdout: out, stderr: "", exitCode: 1 };
+};
+
+/* ------------------------------------------------------------------ */
+/*  sed                                                                */
+/* ------------------------------------------------------------------ */
+
+interface SedCmd {
+  addr?:
+    | { type: "line"; n: number }
+    | { type: "range"; from: number; to: number }
+    | { type: "last" }
+    | { type: "regex"; re: RegExp };
+  type: string;
+  pattern?: string;
+  replacement?: string;
+  sFlags?: string;
+  text?: string;
+  printAfter?: boolean;
+}
+
+function parseSedScript(script: string): SedCmd[] | string {
+  const cmds: SedCmd[] = [];
+  const parts = script.split(/\s*;\s*|\n/).filter(Boolean);
+
+  for (const part of parts) {
+    let rest = part.trim();
+    if (!rest) continue;
+
+    let addr: SedCmd["addr"];
+    if (rest[0] === "$") {
+      addr = { type: "last" };
+      rest = rest.slice(1);
+    } else if (/^\d/.test(rest)) {
+      const m = rest.match(/^(\d+)(?:,(\d+|\$))?/);
+      if (m) {
+        rest = rest.slice(m[0].length);
+        if (m[2]) {
+          const to = m[2] === "$" ? Infinity : parseInt(m[2]);
+          addr = { type: "range", from: parseInt(m[1]), to };
+        } else {
+          addr = { type: "line", n: parseInt(m[1]) };
+        }
+      }
+    } else if (rest[0] === "/") {
+      const end = rest.indexOf("/", 1);
+      if (end > 0) {
+        const pattern = rest.slice(1, end);
+        try {
+          addr = { type: "regex", re: new RegExp(pattern) };
+        } catch {
+          return `invalid regular expression: ${pattern}`;
+        }
+        rest = rest.slice(end + 1);
+      }
+    }
+
+    const cmd = rest[0];
+    rest = rest.slice(1);
+
+    if (cmd === "s") {
+      const delim = rest[0];
+      if (!delim) return `unsupported expression: ${part}`;
+      const parts2 = rest.slice(1).split(delim);
+      if (parts2.length < 2) return `unsupported expression: ${part}`;
+      const printAfter = parts2[2]?.includes("p") ?? false;
+      const sFlags = (parts2[2] ?? "").replace("p", "") || undefined;
+      cmds.push({ addr, type: "s", pattern: parts2[0], replacement: parts2[1], sFlags, printAfter });
+    } else if (cmd === "d") { cmds.push({ addr, type: "d" }); }
+    else if (cmd === "p") { cmds.push({ addr, type: "p" }); }
+    else if (cmd === "q") { cmds.push({ addr, type: "q" }); }
+    else if (cmd === "a") { cmds.push({ addr, type: "a", text: rest.replace(/^\\?\s*/, "") }); }
+    else if (cmd === "i") { cmds.push({ addr, type: "i", text: rest.replace(/^\\?\s*/, "") }); }
+    else if (cmd === "c") { cmds.push({ addr, type: "c", text: rest.replace(/^\\?\s*/, "") }); }
+    else if (cmd === "y") {
+      const delim2 = rest[0];
+      const parts2 = rest.slice(1).split(delim2);
+      if (parts2.length < 2) return `unsupported expression: ${part}`;
+      cmds.push({ addr, type: "y", pattern: parts2[0], replacement: parts2[1] });
+    } else if (cmd === "=") { cmds.push({ addr, type: "=" }); }
+    else { return `unsupported command: ${cmd}`; }
+  }
+  return cmds;
+}
+
+function sedAddressMatch(
+  addr: SedCmd["addr"],
+  lineNum: number,
+  totalLines: number,
+  _line: string,
+): boolean {
+  if (!addr) return true;
+  if (addr.type === "line") return lineNum === addr.n;
+  if (addr.type === "range")
+    return lineNum >= addr.from && lineNum <= (addr.to === Infinity ? totalLines : addr.to);
+  if (addr.type === "last") return lineNum === totalLines;
+  if (addr.type === "regex") return addr.re.test(_line);
+  return true;
+}
+
+const sed_cmd: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, positional } = parseArgs(args, ["i", "n", "r", "E"]);
+  const inPlace = flags.has("i");
+  const quietMode = flags.has("n");
+
+  if (positional.length === 0) return fail("sed: missing expression\n");
+
+  const expressions = positional[0];
+  const files = positional.slice(1);
+
+  const cmds = parseSedScript(expressions);
+  if (typeof cmds === "string") return fail(`sed: ${cmds}\n`);
+
+  const doSed = (content: string): string => {
+    const lines = content.split("\n");
+    let out = "";
+    for (let i = 0; i < lines.length; i++) {
+      const lineNum = i + 1;
+      const isLast = i === lines.length - 1;
+      let line = lines[i];
+      let suppress = quietMode;
+      let deleted = false;
+
+      for (const cmd of cmds) {
+        if (deleted) break;
+        if (!sedAddressMatch(cmd.addr, lineNum, lines.length, line)) continue;
+
+        switch (cmd.type) {
+          case "s": {
+            let re: RegExp;
+            try {
+              re = new RegExp(cmd.pattern!, cmd.sFlags || undefined);
+            } catch {
+              break;
+            }
+            line = line.replace(re, cmd.replacement!);
+            if (cmd.printAfter && re.test(lines[i])) suppress = false;
+            break;
+          }
+          case "d": deleted = true; break;
+          case "p": out += line + "\n"; break;
+          case "q": { if (!suppress) out += line + "\n"; return out; }
+          case "a": out += line + "\n" + cmd.text! + "\n"; suppress = true; break;
+          case "i": out += cmd.text! + "\n"; break;
+          case "c": out += cmd.text! + "\n"; deleted = true; break;
+          case "y": {
+            const from = cmd.pattern!;
+            const to = cmd.replacement!;
+            let result = "";
+            for (const ch of line) {
+              const idx = from.indexOf(ch);
+              result += idx >= 0 ? to[idx] : ch;
+            }
+            line = result;
+            break;
+          }
+          case "=": out += lineNum + "\n"; break;
+        }
+      }
+      if (!deleted && !suppress) {
+        out += line + (isLast && !content.endsWith("\n") ? "" : "\n");
+      }
+    }
+    return out;
+  };
+
+  if (files.length === 0 && stdin !== undefined) return ok(doSed(stdin));
+  if (files.length === 0) return fail("sed: missing input\n");
+
+  let out = "";
+  for (const file of files) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const content = ctx.volume.readFileSync(p, "utf8");
+      const result = doSed(content);
+      if (inPlace) {
+        ctx.volume.writeFileSync(p, result);
+      } else {
+        out += result;
+      }
+    } catch {
+      return fail(`sed: ${file}: No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+/* ------------------------------------------------------------------ */
+/*  sort                                                               */
+/* ------------------------------------------------------------------ */
+
+const sort_cmd: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, opts, positional } = parseArgs(
+    args,
+    ["r", "n", "u", "f", "h", "V", "b", "s"],
+    ["k", "t", "o"],
+  );
+  const reverse = flags.has("r");
+  const numeric = flags.has("n");
+  const unique = flags.has("u");
+  const ignoreCase = flags.has("f");
+  const humanNumeric = flags.has("h");
+  const versionSort = flags.has("V");
+  const stable = flags.has("s");
+  const keySpec = opts["k"];
+  const fieldSep = opts["t"];
+  const outputFile = opts["o"];
+
+  let content = stdin ?? "";
+  if (positional.length > 0) {
+    const p = resolvePath(positional[0], ctx.cwd);
+    try {
+      content = ctx.volume.readFileSync(p, "utf8");
+    } catch {
+      return fail(`sort: ${positional[0]}: No such file or directory\n`);
+    }
+  }
+
+  let lines = content.split("\n").filter(Boolean);
+
+  const getKey = (line: string): string => {
+    if (!keySpec) return line;
+    const sep = fieldSep || /\s+/;
+    const fields = line.split(sep);
+    const [startSpec, endSpec] = keySpec.split(",");
+    const startField = parseInt(startSpec) - 1;
+    const endField = endSpec ? parseInt(endSpec) - 1 : startField;
+    return fields
+      .slice(startField, endField + 1)
+      .join(typeof sep === "string" ? sep : " ");
+  };
+
+  const parseHumanSize = (s: string): number => {
+    const m = s.trim().match(/^([\d.]+)([KMGTPE]i?)?$/i);
+    if (!m) return 0;
+    const n = parseFloat(m[1]);
+    const u = (m[2] || "").toUpperCase().replace("I", "");
+    const mult: Record<string, number> = {
+      "": 1, K: 1024, M: 1048576, G: 1073741824, T: 1099511627776,
+    };
+    return n * (mult[u] || 1);
+  };
+
+  const compare = (a: string, b: string): number => {
+    let ka = getKey(a), kb = getKey(b);
+    if (ignoreCase) { ka = ka.toLowerCase(); kb = kb.toLowerCase(); }
+    if (numeric) return parseFloat(ka) - parseFloat(kb);
+    if (humanNumeric) return parseHumanSize(ka) - parseHumanSize(kb);
+    if (versionSort)
+      return ka.localeCompare(kb, undefined, { numeric: true, sensitivity: "base" });
+    return ka.localeCompare(kb);
+  };
+
+  if (stable) {
+    const indexed = lines.map((l, i) => ({ l, i }));
+    indexed.sort((a, b) => compare(a.l, b.l) || a.i - b.i);
+    lines = indexed.map((x) => x.l);
+  } else {
+    lines.sort(compare);
+  }
+  if (reverse) lines.reverse();
+  if (unique) {
+    const seen = new Set<string>();
+    lines = lines.filter((l) => {
+      const k = ignoreCase ? getKey(l).toLowerCase() : getKey(l);
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+  }
+
+  const result = lines.join("\n") + (lines.length ? "\n" : "");
+  if (outputFile) {
+    const p = resolvePath(outputFile, ctx.cwd);
+    try {
+      ctx.volume.writeFileSync(p, result);
+    } catch {
+      /* */
+    }
+  }
+  return ok(result);
+};
+
+/* ------------------------------------------------------------------ */
+/*  uniq                                                               */
+/* ------------------------------------------------------------------ */
+
+const uniq_cmd: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, opts, positional } = parseArgs(
+    args,
+    ["c", "d", "u", "i"],
+    ["f", "s", "w"],
+  );
+  const count = flags.has("c");
+  const dupsOnly = flags.has("d");
+  const uniqueOnly = flags.has("u");
+  const ignoreCase = flags.has("i");
+  const skipFields = parseInt(opts["f"] || "0");
+  const skipChars = parseInt(opts["s"] || "0");
+  const checkChars = opts["w"] ? parseInt(opts["w"]) : Infinity;
+
+  let content = stdin ?? "";
+  if (positional.length > 0) {
+    const p = resolvePath(positional[0], ctx.cwd);
+    try {
+      content = ctx.volume.readFileSync(p, "utf8");
+    } catch {
+      return fail(`uniq: ${positional[0]}: No such file or directory\n`);
+    }
+  }
+
+  const getKey = (line: string): string => {
+    let l = line;
+    if (skipFields > 0) {
+      const parts = l.split(/\s+/);
+      l = parts.slice(skipFields).join(" ");
+    }
+    if (skipChars > 0) l = l.slice(skipChars);
+    if (checkChars < Infinity) l = l.slice(0, checkChars);
+    if (ignoreCase) l = l.toLowerCase();
+    return l;
+  };
+
+  const lines = content.split("\n");
+  const result: string[] = [];
+  let prev = "";
+  let prevLine = "";
+  let prevCount = 0;
+
+  for (const line of lines) {
+    const key = getKey(line);
+    if (key === prev) {
+      prevCount++;
+    } else {
+      if (prevCount > 0) {
+        const show = dupsOnly ? prevCount > 1 : uniqueOnly ? prevCount === 1 : true;
+        if (show)
+          result.push(count ? `${String(prevCount).padStart(7)} ${prevLine}` : prevLine);
+      }
+      prev = key;
+      prevLine = line;
+      prevCount = 1;
+    }
+  }
+  if (prevCount > 0 && prevLine !== "") {
+    const show = dupsOnly ? prevCount > 1 : uniqueOnly ? prevCount === 1 : true;
+    if (show)
+      result.push(count ? `${String(prevCount).padStart(7)} ${prevLine}` : prevLine);
+  }
+
+  return ok(result.join("\n") + (result.length ? "\n" : ""));
+};
+
+/* ------------------------------------------------------------------ */
+/*  tr                                                                 */
+/* ------------------------------------------------------------------ */
+
+function expandRange(s: string): string {
+  return s.replace(/(.)-(.)/g, (_, a: string, b: string) => {
+    let result = "";
+    const start = a.charCodeAt(0);
+    const end = b.charCodeAt(0);
+    for (let i = start; i <= end; i++) result += String.fromCharCode(i);
+    return result;
+  });
+}
+
+function squeezeDups(s: string, chars: Set<string>): string {
+  let out = "";
+  let prev = "";
+  for (const ch of s) {
+    if (ch === prev && chars.has(ch)) continue;
+    out += ch;
+    prev = ch;
+  }
+  return out;
+}
+
+function buildComplement(set: string): string {
+  const setChars = new Set(set);
+  let result = "";
+  for (let i = 0; i < 128; i++) {
+    const ch = String.fromCharCode(i);
+    if (!setChars.has(ch)) result += ch;
+  }
+  return result;
+}
+
+const tr_cmd: BuiltinFn = (args, _ctx, stdin) => {
+  const { flags, positional } = parseArgs(args, ["d", "s", "c", "C"]);
+  const deleteMode = flags.has("d");
+  const squeeze = flags.has("s");
+  const complement = flags.has("c") || flags.has("C");
+
+  if (positional.length === 0) return fail("tr: missing operand\n");
+  const content = stdin ?? "";
+
+  let set1 = expandCharClass(positional[0]);
+  const set2 = positional.length > 1 ? expandCharClass(positional[1]) : "";
+
+  set1 = expandRange(set1);
+  const expandedSet2 = set2 ? expandRange(set2) : "";
+
+  if (deleteMode) {
+    const chars = complement ? null : new Set(set1);
+    let out = "";
+    for (const ch of content) {
+      const inSet = chars ? chars.has(ch) : set1.includes(ch);
+      if (complement ? inSet : !inSet) out += ch;
+    }
+    if (squeeze && expandedSet2) {
+      const squeezeSet = new Set(expandedSet2);
+      out = squeezeDups(out, squeezeSet);
+    }
+    return ok(out);
+  }
+
+  if (positional.length < 2 && !squeeze) return fail("tr: missing operand\n");
+
+  if (squeeze && positional.length === 1) {
+    const squeezeSet = new Set(set1);
+    return ok(squeezeDups(content, squeezeSet));
+  }
+
+  let out = "";
+  const s1 = complement ? buildComplement(set1) : set1;
+  for (const ch of content) {
+    const idx = s1.indexOf(ch);
+    if (idx >= 0) {
+      const replacement =
+        idx < expandedSet2.length
+          ? expandedSet2[idx]
+          : expandedSet2[expandedSet2.length - 1] || ch;
+      out += replacement;
+    } else {
+      out += ch;
+    }
+  }
+
+  if (squeeze) {
+    const squeezeSet = new Set(expandedSet2);
+    out = squeezeDups(out, squeezeSet);
+  }
+  return ok(out);
+};
+
+/* ------------------------------------------------------------------ */
+/*  cut                                                                */
+/* ------------------------------------------------------------------ */
+
+function parseRangeSpec(spec: string): number[] {
+  const result: number[] = [];
+  for (const part of spec.split(",")) {
+    const range = part.match(/^(\d+)-(\d*)$/);
+    if (range) {
+      const start = parseInt(range[1]);
+      const end = range[2] ? parseInt(range[2]) : start + 100;
+      for (let i = start; i <= end; i++) result.push(i);
+    } else {
+      result.push(parseInt(part));
+    }
+  }
+  return result.filter((n) => !isNaN(n));
+}
+
+const cut_cmd: BuiltinFn = (args, ctx, stdin) => {
+  let delimiter = "\t";
+  let fields: number[] = [];
+  let bytes: number[] = [];
+  let chars: number[] = [];
+  let outputDelimiter: string | null = null;
+  const files: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-d" && i + 1 < args.length) delimiter = args[++i];
+    else if (args[i] === "-f" && i + 1 < args.length)
+      fields = parseRangeSpec(args[++i]);
+    else if (args[i] === "-b" && i + 1 < args.length)
+      bytes = parseRangeSpec(args[++i]);
+    else if (args[i] === "-c" && i + 1 < args.length)
+      chars = parseRangeSpec(args[++i]);
+    else if (args[i] === "--output-delimiter" && i + 1 < args.length)
+      outputDelimiter = args[++i];
+    else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+
+  const outDelim = outputDelimiter ?? delimiter;
+
+  const doCut = (content: string) => {
+    return content
+      .split("\n")
+      .map((line) => {
+        if (bytes.length > 0 || chars.length > 0) {
+          const indices = bytes.length > 0 ? bytes : chars;
+          return indices.map((idx) => line[idx - 1] ?? "").join("");
+        }
+        const parts = line.split(delimiter);
+        return fields.map((f) => parts[f - 1] ?? "").join(outDelim);
+      })
+      .join("\n");
+  };
+
+  if (files.length === 0) return ok(doCut(stdin ?? ""));
+  let out = "";
+  for (const file of files) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      out += doCut(ctx.volume.readFileSync(p, "utf8"));
+    } catch {
+      return fail(`cut: ${file}: No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+/* ------------------------------------------------------------------ */
+/*  Small text utilities                                               */
+/* ------------------------------------------------------------------ */
+
+const rev_cmd: BuiltinFn = (args, ctx, stdin) => {
+  let content = stdin ?? "";
+  if (args.length > 0) {
+    const p = resolvePath(args[0], ctx.cwd);
+    try {
+      content = ctx.volume.readFileSync(p, "utf8");
+    } catch {
+      return fail(`rev: ${args[0]}: No such file or directory\n`);
+    }
+  }
+  return ok(
+    content
+      .split("\n")
+      .map((l) => [...l].reverse().join(""))
+      .join("\n"),
+  );
+};
+
+const paste_cmd: BuiltinFn = (args, ctx, stdin) => {
+  const { opts, positional } = parseArgs(args, ["s"], ["d"]);
+  const delim = opts["d"] || "\t";
+
+  const contents: string[][] = [];
+  for (const file of positional) {
+    if (file === "-" && stdin) {
+      contents.push(stdin.split("\n"));
+      continue;
+    }
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      contents.push(ctx.volume.readFileSync(p, "utf8").split("\n"));
+    } catch {
+      return fail(`paste: ${file}: No such file or directory\n`);
+    }
+  }
+  if (contents.length === 0 && stdin) contents.push(stdin.split("\n"));
+
+  const maxLen = Math.max(...contents.map((c) => c.length));
+  let out = "";
+  for (let i = 0; i < maxLen; i++) {
+    out += contents.map((c) => c[i] ?? "").join(delim) + "\n";
+  }
+  return ok(out);
+};
+
+const comm_cmd: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["1", "2", "3"]);
+  if (positional.length < 2) return fail("comm: missing operand\n");
+
+  const readFile = (f: string) => {
+    const p = resolvePath(f, ctx.cwd);
+    return ctx.volume.readFileSync(p, "utf8").split("\n").filter(Boolean);
+  };
+
+  try {
+    const a = readFile(positional[0]);
+    const b = readFile(positional[1]);
+    let out = "";
+    let ai = 0, bi = 0;
+    while (ai < a.length || bi < b.length) {
+      if (ai >= a.length) {
+        if (!flags.has("2"))
+          out += "\t" + (flags.has("1") ? "" : "\t") + b[bi] + "\n";
+        bi++;
+      } else if (bi >= b.length) {
+        if (!flags.has("1")) out += a[ai] + "\n";
+        ai++;
+      } else if (a[ai] < b[bi]) {
+        if (!flags.has("1")) out += a[ai] + "\n";
+        ai++;
+      } else if (a[ai] > b[bi]) {
+        if (!flags.has("2"))
+          out += "\t" + (flags.has("1") ? "" : "\t") + b[bi] + "\n";
+        bi++;
+      } else {
+        if (!flags.has("3")) out += "\t\t" + a[ai] + "\n";
+        ai++;
+        bi++;
+      }
+    }
+    return ok(out);
+  } catch (e) {
+    return fail(`comm: ${e instanceof Error ? e.message : String(e)}\n`);
+  }
+};
+
+/* ------------------------------------------------------------------ */
+/*  diff                                                               */
+/* ------------------------------------------------------------------ */
+
+function simpleLCS(a: string[], b: string[]): string[] {
+  const m = a.length, n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () =>
+    new Array(n + 1).fill(0),
+  );
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] =
+        a[i - 1] === b[j - 1]
+          ? dp[i - 1][j - 1] + 1
+          : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+  const result: string[] = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) i--;
+    else j--;
+  }
+  return result;
+}
+
+const diff_cmd: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["u", "q", "r", "N"]);
+  if (positional.length < 2) return fail("diff: missing operand\n");
+
+  const brief = flags.has("q");
+  const unified = flags.has("u");
+
+  const p1 = resolvePath(positional[0], ctx.cwd);
+  const p2 = resolvePath(positional[1], ctx.cwd);
+
+  try {
+    const a = ctx.volume.readFileSync(p1, "utf8").split("\n");
+    const b = ctx.volume.readFileSync(p2, "utf8").split("\n");
+
+    if (a.join("\n") === b.join("\n")) return ok();
+    if (brief)
+      return {
+        stdout: `Files ${positional[0]} and ${positional[1]} differ\n`,
+        stderr: "",
+        exitCode: 1,
+      };
+
+    let out = "";
+    if (unified) {
+      out += `--- ${positional[0]}\n+++ ${positional[1]}\n`;
+      out += `@@ -1,${a.length} +1,${b.length} @@\n`;
+      const lcs = simpleLCS(a, b);
+      let ai = 0, bi = 0, li = 0;
+      while (ai < a.length || bi < b.length) {
+        if (
+          li < lcs.length &&
+          ai < a.length && a[ai] === lcs[li] &&
+          bi < b.length && b[bi] === lcs[li]
+        ) {
+          out += ` ${a[ai]}\n`;
+          ai++; bi++; li++;
+        } else if (ai < a.length && (li >= lcs.length || a[ai] !== lcs[li])) {
+          out += `-${a[ai]}\n`;
+          ai++;
+        } else if (bi < b.length) {
+          out += `+${b[bi]}\n`;
+          bi++;
+        }
+      }
+    } else {
+      for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        if (i >= a.length) out += `> ${b[i]}\n`;
+        else if (i >= b.length) out += `< ${a[i]}\n`;
+        else if (a[i] !== b[i]) {
+          out += `< ${a[i]}\n---\n> ${b[i]}\n`;
+        }
+      }
+    }
+
+    return { stdout: out, stderr: "", exitCode: 1 };
+  } catch (e) {
+    return fail(`diff: ${e instanceof Error ? e.message : String(e)}\n`);
+  }
+};
+
+/* ------------------------------------------------------------------ */
+/*  seq / yes                                                          */
+/* ------------------------------------------------------------------ */
+
+const seq_cmd: BuiltinFn = (args) => {
+  if (args.length === 0) return fail("seq: missing operand\n");
+  let first = 1, increment = 1, last = 1;
+  if (args.length === 1) {
+    last = parseFloat(args[0]);
+  } else if (args.length === 2) {
+    first = parseFloat(args[0]);
+    last = parseFloat(args[1]);
+  } else {
+    first = parseFloat(args[0]);
+    increment = parseFloat(args[1]);
+    last = parseFloat(args[2]);
+  }
+
+  const lines: string[] = [];
+  if (increment > 0) {
+    for (let i = first; i <= last; i += increment) lines.push(String(i));
+  } else if (increment < 0) {
+    for (let i = first; i >= last; i += increment) lines.push(String(i));
+  }
+  return ok(lines.join("\n") + (lines.length ? "\n" : ""));
+};
+
+const yes_cmd: BuiltinFn = (args) => {
+  const text = args.length > 0 ? args.join(" ") : "y";
+  return ok((text + "\n").repeat(YES_REPEAT_COUNT));
+};
+
+/* ------------------------------------------------------------------ */
+/*  Registry                                                           */
+/* ------------------------------------------------------------------ */
+
+export const textProcessingCommands: [string, BuiltinFn][] = [
+  ["echo", echo],
+  ["printf", printf_cmd],
+  ["grep", grep_cmd],
+  ["egrep", grep_cmd],
+  ["fgrep", grep_cmd],
+  ["sed", sed_cmd],
+  ["sort", sort_cmd],
+  ["uniq", uniq_cmd],
+  ["tr", tr_cmd],
+  ["cut", cut_cmd],
+  ["rev", rev_cmd],
+  ["paste", paste_cmd],
+  ["comm", comm_cmd],
+  ["diff", diff_cmd],
+  ["seq", seq_cmd],
+  ["yes", yes_cmd],
+];