fix(coding-agent): align stripAnsi with strip-ansi

packages/coding-agent/src/utils/ansi.ts

@@ -1,87 +1,60 @@
+/*
+ * Portions of this file are derived from:
+ * - ansi-regex (https://github.com/chalk/ansi-regex)
+ * - strip-ansi (https://github.com/chalk/strip-ansi)
+ *
+ * MIT License
+ *
+ * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function ansiRegex({ onlyFirst = false }: { onlyFirst?: boolean } = {}): RegExp {
+	// Valid string terminator sequences are BEL, ESC\, and 0x9c
+	const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+
+	// OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
+	const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+
+	// CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
+	const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+
+	const pattern = `${osc}|${csi}`;
+
+	return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+
+const regex = ansiRegex();
+
 export function stripAnsi(value: string): string {
-	let output = "";
+	if (typeof value !== "string") {
-	let index = 0;
+		throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
-
-	while (index < value.length) {
-		const code = value.charCodeAt(index);
-
-		if (code === 0x1b) {
-			const next = value[index + 1];
-
-			if (next === "[") {
-				index = skipCsi(value, index + 2);
-				continue;
-			}
-
-			if (next === "]" || next === "P" || next === "^" || next === "_") {
-				index = skipStringControl(value, index + 2);
-				continue;
-			}
-
-			if (next && "()*+-./#".includes(next)) {
-				index = Math.min(index + 3, value.length);
-				continue;
-			}
-
-			if (next && isEscFinalByte(next.charCodeAt(0))) {
-				index += 2;
-				continue;
-			}
-		} else if (code === 0x9b) {
-			index = skipCsi(value, index + 1);
-			continue;
-		} else if (code === 0x9d || code === 0x90 || code === 0x9e || code === 0x9f) {
-			index = skipStringControl(value, index + 1);
-			continue;
-		}
-
-		output += value[index];
-		index++;
 	}
 
-	return output;
+	// Fast path: ANSI codes require ESC (7-bit) or CSI (8-bit) introducer
-}
+	if (!value.includes("\u001B") && !value.includes("\u009B")) {
-
+		return value;
-function isEscFinalByte(code: number): boolean {
-	return (
-		(code >= 0x30 && code <= 0x39) ||
-		(code >= 0x41 && code <= 0x50) ||
-		(code >= 0x52 && code <= 0x54) ||
-		code === 0x5a ||
-		code === 0x63 ||
-		(code >= 0x66 && code <= 0x6e) ||
-		(code >= 0x71 && code <= 0x75) ||
-		code === 0x79 ||
-		code === 0x3d ||
-		code === 0x3e ||
-		code === 0x3c ||
-		code === 0x7e
-	);
-}
-
-function skipCsi(value: string, start: number): number {
-	let index = start;
-	while (index < value.length) {
-		const code = value.charCodeAt(index);
-		index++;
-		if (code >= 0x40 && code <= 0x7e) {
-			return index;
-		}
 	}
-	return value.length;
-}
 
-function skipStringControl(value: string, start: number): number {
+	// Even though the regex is global, we don't need to reset the `.lastIndex`
-	let index = start;
+	// because unlike `.exec()` and `.test()`, `.replace()` does it automatically
-	while (index < value.length) {
+	// and doing it manually has a performance penalty.
-		const code = value.charCodeAt(index);
+	return value.replace(regex, "");
-		if (code === 0x07 || code === 0x9c) {
-			return index + 1;
-		}
-		if (code === 0x1b && value[index + 1] === "\\") {
-			return index + 2;
-		}
-		index++;
-	}
-	return value.length;
 }

packages/coding-agent/test/ansi-utils.test.ts

@@ -1,7 +1,95 @@
 import { describe, expect, it } from "vitest";
 import { stripAnsi } from "../src/utils/ansi.js";
 
+function referenceAnsiRegex(): RegExp {
+	const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+	const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+	const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+	return new RegExp(`${osc}|${csi}`, "g");
+}
+
+const referenceRegex = referenceAnsiRegex();
+
+function referenceStripAnsi(value: string): string {
+	if (!value.includes("\u001B") && !value.includes("\u009B")) {
+		return value;
+	}
+	return value.replace(referenceRegex, "");
+}
+
+function getCompatibilityInputs(): string[] {
+	const inputs = [
+		"plain",
+		"a\x1b[31mred\x1b[0mz",
+		"a\x1b]8;;https://example.com\x07link\x1b]8;;\x07z",
+		"a\x1b]unterminated",
+		"a\x1b]funterminated",
+		"a\x1bPabc\x1b\\z",
+		"a\x1b^abc\x07z",
+		"a\x1b_abc\x9cz",
+		"a\x90abc\x9cz",
+		"a\x9dabc\x9cz",
+		"a\x9b31mred",
+		"a\x1b(0x",
+		"a\x1b*0x",
+		"a\x1b+c",
+		"a\x1b/0x",
+		"a\x1bcok",
+		"a\x1b\\ok",
+	];
+	const chars = [
+		"a",
+		"f",
+		"0",
+		"1",
+		";",
+		":",
+		"[",
+		"]",
+		"(",
+		")",
+		"#",
+		"?",
+		"m",
+		"P",
+		"_",
+		"\\",
+		"\x07",
+		"\x1b",
+		"\x9b",
+		"\x9c",
+		"\x90",
+		"\x9d",
+	];
+
+	for (const char of chars) {
+		inputs.push(`x\x1b${char}y`);
+		inputs.push(`x\x9b${char}y`);
+		for (let index = 0; index < chars.length; index += 3) {
+			inputs.push(`x\x1b${char}${chars[index]}y`);
+		}
+	}
+
+	return inputs;
+}
+
 describe("stripAnsi", () => {
+	it("matches chalk strip-ansi for generated compatibility inputs", () => {
+		for (const input of getCompatibilityInputs()) {
+			expect(stripAnsi(input)).toBe(referenceStripAnsi(input));
+		}
+	});
+
+	it("throws the same TypeError as chalk strip-ansi for non-string values", () => {
+		const stripAnsiUnknown = stripAnsi as (value: unknown) => string;
+
+		for (const value of [undefined, null, 123, {}, Object("x")]) {
+			const message = `Expected a \`string\`, got \`${typeof value}\``;
+			expect(() => stripAnsiUnknown(value)).toThrow(TypeError);
+			expect(() => stripAnsiUnknown(value)).toThrow(message);
+		}
+	});
+
 	it("strips RIS without leaking the final byte", () => {
 		expect(stripAnsi("\x1bcdone")).toBe("done");
 	});