@quantiya/codevibe-claude-plugin 2.0.8 → 2.0.9

package/node_modules/wrap-ansi/index.js

@@ -2,253 +2,33 @@ import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
 import ansiStyles from 'ansi-styles';
 
-const ANSI_ESCAPE = '\u001B';
-const ANSI_ESCAPE_CSI = '\u009B';
 const ESCAPES = new Set([
-	ANSI_ESCAPE,
-	ANSI_ESCAPE_CSI,
+	'\u001B',
+	'\u009B',
 ]);
 
+const END_CODE = 39;
 const ANSI_ESCAPE_BELL = '\u0007';
 const ANSI_CSI = '[';
 const ANSI_OSC = ']';
 const ANSI_SGR_TERMINATOR = 'm';
-const ANSI_SGR_RESET = 0;
-const ANSI_SGR_RESET_FOREGROUND = 39;
-const ANSI_SGR_RESET_BACKGROUND = 49;
-const ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
-const ANSI_SGR_FOREGROUND_EXTENDED = 38;
-const ANSI_SGR_BACKGROUND_EXTENDED = 48;
-const ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
-const ANSI_SGR_COLOR_MODE_256 = 5;
-const ANSI_SGR_COLOR_MODE_RGB = 2;
 const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-const ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
-const ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
-const ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(ansiStyles.codes.values());
-ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
 
-const segmenter = new Intl.Segmenter();
-const getGraphemes = string => Array.from(segmenter.segment(string), ({segment}) => segment);
-const TAB_SIZE = 8;
-
-const wrapAnsiCode = code => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-const wrapAnsiHyperlink = url => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
-
-const getSgrTokens = sgrParameters => {
-	const codes = sgrParameters.split(';').map(sgrParameter => sgrParameter === '' ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
-	const sgrTokens = [];
-
-	for (let index = 0; index < codes.length; index++) {
-		const code = codes[index];
-
-		if (!Number.isFinite(code)) {
-			continue;
-		}
-
-		if (
-			(
-				code === ANSI_SGR_FOREGROUND_EXTENDED
-				|| code === ANSI_SGR_BACKGROUND_EXTENDED
-				|| code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED
-			)
-		) {
-			if (index + 1 >= codes.length) {
-				break;
-			}
-
-			const mode = codes[index + 1];
-
-			if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
-				sgrTokens.push([code, mode, codes[index + 2]]);
-				index += 2;
-				continue;
-			}
-
-			const red = codes[index + 2];
-			const green = codes[index + 3];
-			const blue = codes[index + 4];
-			if (
-				mode === ANSI_SGR_COLOR_MODE_RGB
-				&& Number.isFinite(red)
-				&& Number.isFinite(green)
-				&& Number.isFinite(blue)
-			) {
-				sgrTokens.push([code, mode, red, green, blue]);
-				index += 4;
-				continue;
-			}
-
-			break;
-		}
-
-		sgrTokens.push([code]);
-	}
-
-	return sgrTokens;
-};
-
-const removeActiveStyle = (activeStyles, family) => {
-	const activeStyleIndex = activeStyles.findIndex(activeStyle => activeStyle.family === family);
-
-	if (activeStyleIndex !== -1) {
-		activeStyles.splice(activeStyleIndex, 1);
-	}
-};
-
-const upsertActiveStyle = (activeStyles, nextActiveStyle) => {
-	removeActiveStyle(activeStyles, nextActiveStyle.family);
-	activeStyles.push(nextActiveStyle);
-};
-
-const removeModifierStylesByClose = (activeStyles, closeCode) => {
-	for (let index = activeStyles.length - 1; index >= 0; index--) {
-		const activeStyle = activeStyles[index];
-		if (activeStyle.family.startsWith('modifier-') && activeStyle.close === closeCode) {
-			activeStyles.splice(index, 1);
-		}
-	}
-};
-
-const getColorStyle = (code, sgrToken) => {
-	if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97) || (code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1)) {
-		return {
-			family: 'foreground',
-			open: sgrToken.join(';'),
-			close: ANSI_SGR_RESET_FOREGROUND,
-		};
-	}
-
-	if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107) || (code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1)) {
-		return {
-			family: 'background',
-			open: sgrToken.join(';'),
-			close: ANSI_SGR_RESET_BACKGROUND,
-		};
-	}
-
-	if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
-		return {
-			family: 'underlineColor',
-			open: sgrToken.join(';'),
-			close: ANSI_SGR_RESET_UNDERLINE_COLOR,
-		};
-	}
-};
-
-const applySgrResetCode = (code, activeStyles) => {
-	if (code === ANSI_SGR_RESET) {
-		activeStyles.length = 0;
-		return true;
-	}
-
-	if (code === ANSI_SGR_RESET_FOREGROUND) {
-		removeActiveStyle(activeStyles, 'foreground');
-		return true;
-	}
-
-	if (code === ANSI_SGR_RESET_BACKGROUND) {
-		removeActiveStyle(activeStyles, 'background');
-		return true;
-	}
-
-	if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
-		removeActiveStyle(activeStyles, 'underlineColor');
-		return true;
-	}
-
-	if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
-		removeModifierStylesByClose(activeStyles, code);
-		return true;
-	}
-
-	return false;
-};
-
-const applySgrToken = (sgrToken, activeStyles) => {
-	const [code] = sgrToken;
-
-	if (applySgrResetCode(code, activeStyles)) {
-		return;
-	}
-
-	const colorStyle = getColorStyle(code, sgrToken);
-	if (colorStyle) {
-		upsertActiveStyle(activeStyles, colorStyle);
-		return;
-	}
-
-	const close = ansiStyles.codes.get(code);
-	if (close !== undefined && close !== ANSI_SGR_RESET) {
-		upsertActiveStyle(activeStyles, {
-			family: `modifier-${code}`,
-			open: sgrToken.join(';'),
-			close,
-		});
-	}
-};
-
-const applySgrParameters = (sgrParameters, activeStyles) => {
-	for (const sgrToken of getSgrTokens(sgrParameters)) {
-		applySgrToken(sgrToken, activeStyles);
-	}
-};
-
-const applySgrResets = (sgrParameters, activeStyles) => {
-	for (const sgrToken of getSgrTokens(sgrParameters)) {
-		const [code] = sgrToken;
-		applySgrResetCode(code, activeStyles);
-	}
-};
-
-const applyLeadingSgrResets = (string, activeStyles) => {
-	let remainder = string;
-
-	while (remainder.length > 0) {
-		if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== '\\') {
-			const match = ANSI_ESCAPE_REGEX.exec(remainder);
-			if (!match) {
-				break;
-			}
-
-			if (match.groups.sgr !== undefined) {
-				applySgrResets(match.groups.sgr, activeStyles);
-			}
-
-			remainder = remainder.slice(match[0].length);
-			continue;
-		}
-
-		if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
-			const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
-			if (!match || match.groups.sgr === undefined) {
-				break;
-			}
-
-			applySgrResets(match.groups.sgr, activeStyles);
-			remainder = remainder.slice(match[0].length);
-			continue;
-		}
-
-		break;
-	}
-};
-
-const getClosingSgrSequence = activeStyles => [...activeStyles].reverse().map(activeStyle => wrapAnsiCode(activeStyle.close)).join('');
-const getOpeningSgrSequence = activeStyles => activeStyles.map(activeStyle => wrapAnsiCode(activeStyle.open)).join('');
+const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
 
 // Calculate the length of words split on ' ', ignoring
-// the extra characters added by ANSI escape codes
-const wordLengths = string => string.split(' ').map(word => stringWidth(word));
+// the extra characters added by ansi escape codes
+const wordLengths = string => string.split(' ').map(character => stringWidth(character));
 
 // Wrap a long word across multiple rows
-// ANSI escape codes do not count towards length
+// Ansi escape codes do not count towards length
 const wrapWord = (rows, word, columns) => {
-	const characters = getGraphemes(word);
+	const characters = [...word];
 
 	let isInsideEscape = false;
 	let isInsideLinkEscape = false;
-	let visible = stringWidth(stripAnsi(rows.at(-1)));
+	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
 
 	for (const [index, character] of characters.entries()) {
 		const characterLength = stringWidth(character);
@@ -260,19 +40,14 @@ const wrapWord = (rows, word, columns) => {
 			visible = 0;
 		}
 
-		if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === '\\')) {
+		if (ESCAPES.has(character)) {
 			isInsideEscape = true;
-
-			const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join('');
-			isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
 		}
 
 		if (isInsideEscape) {
 			if (isInsideLinkEscape) {
-				if (
-					character === ANSI_ESCAPE_BELL
-					|| (character === '\\' && index > 0 && characters[index - 1] === ANSI_ESCAPE) // ST terminator (ESC \)
-				) {
+				if (character === ANSI_ESCAPE_BELL) {
 					isInsideEscape = false;
 					isInsideLinkEscape = false;
 				}
@@ -292,8 +67,8 @@ const wrapWord = (rows, word, columns) => {
 	}
 
 	// It's possible that the last row we copy over is only
-	// ANSI escape characters, handle this edge-case
-	if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+	// ansi escape characters, handle this edge-case
+	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
 		rows[rows.length - 2] += rows.pop();
 	}
 };
@@ -318,52 +93,29 @@ const stringVisibleTrimSpacesRight = string => {
 	return words.slice(0, last).join(' ') + words.slice(last).join('');
 };
 
-const expandTabs = line => {
-	if (!line.includes('\t')) {
-		return line;
-	}
-
-	const segments = line.split('\t');
-	let visible = 0;
-	let expandedLine = '';
-
-	for (const [index, segment] of segments.entries()) {
-		expandedLine += segment;
-		visible += stringWidth(segment);
-
-		if (index < segments.length - 1) {
-			const spaces = TAB_SIZE - (visible % TAB_SIZE);
-			expandedLine += ' '.repeat(spaces);
-			visible += spaces;
-		}
-	}
-
-	return expandedLine;
-};
-
-// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode.
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
 //
-// 'hard' will never allow a string to take up more than columns characters.
+// 'hard' will never allow a string to take up more than columns characters
 //
-// 'soft' allows long words to expand past the column length.
+// 'soft' allows long words to expand past the column length
 const exec = (string, columns, options = {}) => {
 	if (options.trim !== false && string.trim() === '') {
 		return '';
 	}
 
 	let returnValue = '';
+	let escapeCode;
 	let escapeUrl;
-	const activeStyles = [];
 
 	const lengths = wordLengths(string);
 	let rows = [''];
 
 	for (const [index, word] of string.split(' ').entries()) {
 		if (options.trim !== false) {
-			rows[rows.length - 1] = rows.at(-1).trimStart();
+			rows[rows.length - 1] = rows[rows.length - 1].trimStart();
 		}
 
-		let rowLength = stringWidth(rows.at(-1));
+		let rowLength = stringWidth(rows[rows.length - 1]);
 
 		if (index !== 0) {
 			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
@@ -379,8 +131,8 @@ const exec = (string, columns, options = {}) => {
 		}
 
 		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
-		if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
-			const remainingColumns = columns - rowLength;
+		if (options.hard && lengths[index] > columns) {
+			const remainingColumns = (columns - rowLength);
 			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
 			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
 			if (breaksStartingNextLine < breaksStartingThisLine) {
@@ -412,46 +164,40 @@ const exec = (string, columns, options = {}) => {
 		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
 	}
 
-	const preString = rows.join('\n');
-	const pre = getGraphemes(preString);
-
-	// We need to keep a separate index as `String#slice()` works on Unicode code units, while `pre` is an array of grapheme clusters.
-	let preStringIndex = 0;
+	const pre = [...rows.join('\n')];
 
 	for (const [index, character] of pre.entries()) {
 		returnValue += character;
 
-		if (character === ANSI_ESCAPE && pre[index + 1] !== '\\') {
-			const {groups} = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || {groups: {}};
-			if (groups.sgr !== undefined) {
-				applySgrParameters(groups.sgr, activeStyles);
+		if (ESCAPES.has(character)) {
+			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
+			if (groups.code !== undefined) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? undefined : code;
 			} else if (groups.uri !== undefined) {
 				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
 			}
-		} else if (character === ANSI_ESCAPE_CSI) {
-			const {groups} = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || {groups: {}};
-			if (groups.sgr !== undefined) {
-				applySgrParameters(groups.sgr, activeStyles);
-			}
 		}
 
+		const code = ansiStyles.codes.get(Number(escapeCode));
+
 		if (pre[index + 1] === '\n') {
 			if (escapeUrl) {
 				returnValue += wrapAnsiHyperlink('');
 			}
 
-			returnValue += getClosingSgrSequence(activeStyles);
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(code);
+			}
 		} else if (character === '\n') {
-			const openingStyles = [...activeStyles];
-			applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
-			returnValue += getOpeningSgrSequence(openingStyles);
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(escapeCode);
+			}
 
 			if (escapeUrl) {
 				returnValue += wrapAnsiHyperlink(escapeUrl);
 			}
 		}
-
-		preStringIndex += character.length;
 	}
 
 	return returnValue;
@@ -461,8 +207,8 @@ const exec = (string, columns, options = {}) => {
 export default function wrapAnsi(string, columns, options) {
 	return String(string)
 		.normalize()
-		.replaceAll('\r\n', '\n')
+		.replace(/\r\n/g, '\n')
 		.split('\n')
-		.map(line => exec(expandTabs(line), columns, options))
+		.map(line => exec(line, columns, options))
 		.join('\n');
 }

package/node_modules/wrap-ansi/node_modules/ansi-styles/index.d.ts

@@ -0,0 +1,236 @@
+export type CSPair = { // eslint-disable-line @typescript-eslint/naming-convention
+	/**
+	The ANSI terminal control sequence for starting this style.
+	*/
+	readonly open: string;
+
+	/**
+	The ANSI terminal control sequence for ending this style.
+	*/
+	readonly close: string;
+};
+
+export type ColorBase = {
+	/**
+	The ANSI terminal control sequence for ending this color.
+	*/
+	readonly close: string;
+
+	ansi(code: number): string;
+
+	ansi256(code: number): string;
+
+	ansi16m(red: number, green: number, blue: number): string;
+};
+
+export type Modifier = {
+	/**
+	Resets the current color chain.
+	*/
+	readonly reset: CSPair;
+
+	/**
+	Make text bold.
+	*/
+	readonly bold: CSPair;
+
+	/**
+	Emitting only a small amount of light.
+	*/
+	readonly dim: CSPair;
+
+	/**
+	Make text italic. (Not widely supported)
+	*/
+	readonly italic: CSPair;
+
+	/**
+	Make text underline. (Not widely supported)
+	*/
+	readonly underline: CSPair;
+
+	/**
+	Make text overline.
+
+	Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
+	*/
+	readonly overline: CSPair;
+
+	/**
+	Inverse background and foreground colors.
+	*/
+	readonly inverse: CSPair;
+
+	/**
+	Prints the text, but makes it invisible.
+	*/
+	readonly hidden: CSPair;
+
+	/**
+	Puts a horizontal line through the center of the text. (Not widely supported)
+	*/
+	readonly strikethrough: CSPair;
+};
+
+export type ForegroundColor = {
+	readonly black: CSPair;
+	readonly red: CSPair;
+	readonly green: CSPair;
+	readonly yellow: CSPair;
+	readonly blue: CSPair;
+	readonly cyan: CSPair;
+	readonly magenta: CSPair;
+	readonly white: CSPair;
+
+	/**
+	Alias for `blackBright`.
+	*/
+	readonly gray: CSPair;
+
+	/**
+	Alias for `blackBright`.
+	*/
+	readonly grey: CSPair;
+
+	readonly blackBright: CSPair;
+	readonly redBright: CSPair;
+	readonly greenBright: CSPair;
+	readonly yellowBright: CSPair;
+	readonly blueBright: CSPair;
+	readonly cyanBright: CSPair;
+	readonly magentaBright: CSPair;
+	readonly whiteBright: CSPair;
+};
+
+export type BackgroundColor = {
+	readonly bgBlack: CSPair;
+	readonly bgRed: CSPair;
+	readonly bgGreen: CSPair;
+	readonly bgYellow: CSPair;
+	readonly bgBlue: CSPair;
+	readonly bgCyan: CSPair;
+	readonly bgMagenta: CSPair;
+	readonly bgWhite: CSPair;
+
+	/**
+	Alias for `bgBlackBright`.
+	*/
+	readonly bgGray: CSPair;
+
+	/**
+	Alias for `bgBlackBright`.
+	*/
+	readonly bgGrey: CSPair;
+
+	readonly bgBlackBright: CSPair;
+	readonly bgRedBright: CSPair;
+	readonly bgGreenBright: CSPair;
+	readonly bgYellowBright: CSPair;
+	readonly bgBlueBright: CSPair;
+	readonly bgCyanBright: CSPair;
+	readonly bgMagentaBright: CSPair;
+	readonly bgWhiteBright: CSPair;
+};
+
+export type ConvertColor = {
+	/**
+	Convert from the RGB color space to the ANSI 256 color space.
+
+	@param red - (`0...255`)
+	@param green - (`0...255`)
+	@param blue - (`0...255`)
+	*/
+	rgbToAnsi256(red: number, green: number, blue: number): number;
+
+	/**
+	Convert from the RGB HEX color space to the RGB color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+	hexToRgb(hex: string): [red: number, green: number, blue: number];
+
+	/**
+	Convert from the RGB HEX color space to the ANSI 256 color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+	hexToAnsi256(hex: string): number;
+
+	/**
+	Convert from the ANSI 256 color space to the ANSI 16 color space.
+
+	@param code - A number representing the ANSI 256 color.
+	*/
+	ansi256ToAnsi(code: number): number;
+
+	/**
+	Convert from the RGB color space to the ANSI 16 color space.
+
+	@param red - (`0...255`)
+	@param green - (`0...255`)
+	@param blue - (`0...255`)
+	*/
+	rgbToAnsi(red: number, green: number, blue: number): number;
+
+	/**
+	Convert from the RGB HEX color space to the ANSI 16 color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+	hexToAnsi(hex: string): number;
+};
+
+/**
+Basic modifier names.
+*/
+export type ModifierName = keyof Modifier;
+
+/**
+Basic foreground color names.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type ForegroundColorName = keyof ForegroundColor;
+
+/**
+Basic background color names.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type BackgroundColorName = keyof BackgroundColor;
+
+/**
+Basic color names. The combination of foreground and background color names.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type ColorName = ForegroundColorName | BackgroundColorName;
+
+/**
+Basic modifier names.
+*/
+export const modifierNames: readonly ModifierName[];
+
+/**
+Basic foreground color names.
+*/
+export const foregroundColorNames: readonly ForegroundColorName[];
+
+/**
+Basic background color names.
+*/
+export const backgroundColorNames: readonly BackgroundColorName[];
+
+/*
+Basic color names. The combination of foreground and background color names.
+*/
+export const colorNames: readonly ColorName[];
+
+declare const ansiStyles: {
+	readonly modifier: Modifier;
+	readonly color: ColorBase & ForegroundColor;
+	readonly bgColor: ColorBase & BackgroundColor;
+	readonly codes: ReadonlyMap<number, number>;
+} & ForegroundColor & BackgroundColor & Modifier & ConvertColor;
+
+export default ansiStyles;