tryscript 0.1.6 → 0.1.7

package/dist/{src-1oEnK7GG.cjs → src-BIZMxxIt.cjs}

@@ -37,6 +37,7 @@ let tree_kill = require("tree-kill");
 tree_kill = __toESM(tree_kill);
 let strip_ansi = require("strip-ansi");
 strip_ansi = __toESM(strip_ansi);
+let atomically = require("atomically");
 
 //#region src/lib/config.ts
 /** Default coverage configuration values. */
@@ -120,8 +121,6 @@ function defineConfig(config) {
 //#region src/lib/parser.ts
 /** Regex to match YAML frontmatter at the start of a file */
 const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
-/** Regex to match fenced code blocks with console/bash info string */
-const CODE_BLOCK_REGEX = /```(console|bash)\r?\n([\s\S]*?)```/g;
 /** Regex to match markdown headings (for test names) */
 const HEADING_REGEX = /^#+\s+(?:Test:\s*)?(.+)$/m;
 /** Regex to match skip annotation in heading or nearby HTML comment */
@@ -129,6 +128,55 @@ const SKIP_ANNOTATION_REGEX = /<!--\s*skip\s*-->/i;
 /** Regex to match only annotation in heading or nearby HTML comment */
 const ONLY_ANNOTATION_REGEX = /<!--\s*only\s*-->/i;
 /**
+* Find console/bash fenced code blocks, supporting extended fences (4+ backticks).
+*
+* Extended fences allow embedding triple-backtick blocks in expected output.
+* A closing fence must have at least as many backticks as the opening fence
+* (per CommonMark spec).
+*/
+function findConsoleCodeBlocks(text) {
+	const results = [];
+	const lines = text.split("\n");
+	const offsets = new Array(lines.length);
+	offsets[0] = 0;
+	for (let j = 1; j < lines.length; j++) offsets[j] = offsets[j - 1] + lines[j - 1].length + 1;
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+		const openMatch = /^(`{3,})(console|bash)\s*$/.exec(trimmed);
+		if (!openMatch) {
+			i++;
+			continue;
+		}
+		const fenceLen = openMatch[1].length;
+		const infoString = openMatch[2];
+		const openLineIdx = i;
+		const closingRe = /* @__PURE__ */ new RegExp(`^\`{${fenceLen},}\\s*$`);
+		i++;
+		while (i < lines.length) {
+			const cur = lines[i];
+			const curTrimmed = cur.endsWith("\r") ? cur.slice(0, -1) : cur;
+			if (closingRe.test(curTrimmed)) {
+				const startOffset = offsets[openLineIdx];
+				const endOffset = offsets[i] + lines[i].length;
+				const contentStart = offsets[openLineIdx + 1];
+				const contentEnd = offsets[i];
+				results.push({
+					fullMatch: text.slice(startOffset, endOffset),
+					infoString,
+					content: text.slice(contentStart, contentEnd),
+					index: startOffset
+				});
+				i++;
+				break;
+			}
+			i++;
+		}
+	}
+	return results;
+}
+/**
 * Parse a .tryscript.md file into structured test data.
 */
 function parseTestFile(content, filePath) {
@@ -141,12 +189,11 @@ function parseTestFile(content, filePath) {
 		body = content.slice(frontmatterMatch[0].length);
 	}
 	const blocks = [];
-	CODE_BLOCK_REGEX.lastIndex = 0;
-	let match;
-	while ((match = CODE_BLOCK_REGEX.exec(body)) !== null) {
-		const blockContent = match[2] ?? "";
-		const blockStart = match.index;
-		const lineNumber = content.slice(0, content.indexOf(match[0])).split("\n").length;
+	const codeBlocks = findConsoleCodeBlocks(body);
+	for (const codeBlock of codeBlocks) {
+		const blockContent = codeBlock.content;
+		const blockStart = codeBlock.index;
+		const lineNumber = content.slice(0, content.indexOf(codeBlock.fullMatch)).split("\n").length;
 		const contentBefore = body.slice(0, blockStart);
 		const lastHeadingMatch = [...contentBefore.matchAll(new RegExp(HEADING_REGEX.source, "gm"))].pop();
 		const name = lastHeadingMatch?.[1]?.trim();
@@ -161,7 +208,7 @@ function parseTestFile(content, filePath) {
 			expectedStderr: parsed.expectedStderr,
 			expectedExitCode: parsed.expectedExitCode,
 			lineNumber,
-			rawContent: match[0],
+			rawContent: codeBlock.fullMatch,
 			skip,
 			only
 		});
@@ -536,9 +583,15 @@ function patternToRegex(expected, customPatterns = {}) {
 	const dotdotMarker = getMarker();
 	replacements.set(dotdotMarker, "[^\\n]*");
 	processed = processed.replaceAll("[..]", dotdotMarker);
+	const unknownDotdotMarker = getMarker();
+	replacements.set(unknownDotdotMarker, "[^\\n]*");
+	processed = processed.replaceAll("[??]", unknownDotdotMarker);
 	const ellipsisMarker = getMarker();
 	replacements.set(ellipsisMarker, "(?:[^\\n]*\\n)*");
 	processed = processed.replace(/\.\.\.\n/g, ellipsisMarker);
+	const unknownEllipsisMarker = getMarker();
+	replacements.set(unknownEllipsisMarker, "(?:[^\\n]*\\n)*");
+	processed = processed.replace(/\?\?\?\n/g, unknownEllipsisMarker);
 	const exeMarker = getMarker();
 	const exe = process.platform === "win32" ? "\\.exe" : "";
 	replacements.set(exeMarker, exe);
@@ -581,6 +634,82 @@ function normalizeOutput(output) {
 	return normalized;
 }
 /**
+* Like `patternToRegex()` but wraps each wildcard in a capturing group and
+* returns metadata describing what each group represents.
+*
+* Each occurrence gets a unique marker so that the `groups` array is ordered
+* by position in the string, matching the regex capture group indices.
+*/
+function patternToCapturingRegex(expected, customPatterns = {}) {
+	const replacements = /* @__PURE__ */ new Map();
+	const markerMeta = /* @__PURE__ */ new Map();
+	let markerIndex = 0;
+	const getMarker = () => {
+		return `${MARKER}${markerIndex++}${MARKER}`;
+	};
+	const replaceEach = (processed$1, pattern, regexStr, meta) => {
+		let result = processed$1;
+		if (typeof pattern === "string") while (result.includes(pattern)) {
+			const marker = getMarker();
+			replacements.set(marker, regexStr);
+			markerMeta.set(marker, meta);
+			result = result.replace(pattern, marker);
+		}
+		else {
+			let m;
+			while ((m = pattern.exec(result)) !== null) {
+				const marker = getMarker();
+				replacements.set(marker, regexStr);
+				markerMeta.set(marker, meta);
+				result = result.slice(0, m.index) + marker + result.slice(m.index + m[0].length);
+			}
+		}
+		return result;
+	};
+	let processed = expected;
+	processed = replaceEach(processed, "[..]", "([^\\n]*)", {
+		category: "generic",
+		multiline: false
+	});
+	processed = replaceEach(processed, "[??]", "([^\\n]*)", {
+		category: "unknown",
+		multiline: false
+	});
+	processed = replaceEach(processed, /\.\.\.\n/, "((?:[^\\n]*\\n)*)", {
+		category: "generic",
+		multiline: true
+	});
+	processed = replaceEach(processed, /\?\?\?\n/, "((?:[^\\n]*\\n)*)", {
+		category: "unknown",
+		multiline: true
+	});
+	const exe = process.platform === "win32" ? "\\.exe" : "";
+	processed = replaceEach(processed, "[EXE]", exe, null);
+	for (const [name, pattern] of Object.entries(customPatterns)) {
+		const placeholder = `[${name}]`;
+		const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
+		processed = replaceEach(processed, placeholder, `(${patternStr})`, {
+			category: "named",
+			name,
+			multiline: false
+		});
+	}
+	const sortedEntries = [...replacements.entries()].sort((a, b) => {
+		return processed.indexOf(a[0]) - processed.indexOf(b[0]);
+	});
+	let regex = escapeRegex(processed);
+	const groups = [];
+	for (const [marker, replacement] of sortedEntries) {
+		const meta = markerMeta.get(marker);
+		if (meta) groups.push(meta);
+		regex = regex.replaceAll(escapeRegex(marker), replacement);
+	}
+	return {
+		regex: new RegExp(`^${regex}$`, "s"),
+		groups
+	};
+}
+/**
 * Check if actual output matches expected pattern.
 */
 function matchOutput(actual, expected, context, customPatterns = {}) {
@@ -589,10 +718,307 @@ function matchOutput(actual, expected, context, customPatterns = {}) {
 	if (normalizedExpected === "" && normalizedActual === "") return true;
 	return patternToRegex(preprocessPaths(normalizedExpected, context), customPatterns).test(normalizedActual);
 }
+/**
+* Match actual output against expected pattern and return wildcard captures.
+* Returns `null` if the output does not match.
+*/
+function matchAndCapture(actual, expected, context, customPatterns = {}) {
+	const normalizedActual = normalizeOutput(actual);
+	const normalizedExpected = normalizeOutput(expected);
+	if (normalizedExpected === "" && normalizedActual === "") return { captures: [] };
+	const { regex, groups } = patternToCapturingRegex(preprocessPaths(normalizedExpected, context), customPatterns);
+	const match = regex.exec(normalizedActual);
+	if (!match) return null;
+	return { captures: groups.map((meta, i) => ({
+		category: meta.category,
+		name: meta.name,
+		multiline: meta.multiline,
+		captured: match[i + 1] ?? ""
+	})) };
+}
+
+//#endregion
+//#region src/lib/expander.ts
+/**
+* Whether a wildcard category should be expanded at the given level.
+*
+* The hierarchy is: unknown < generic < all.
+*/
+function shouldExpandCategory(category, level) {
+	switch (level) {
+		case "unknown": return category === "unknown";
+		case "generic": return category === "unknown" || category === "generic";
+		case "all": return true;
+	}
+}
+const WILDCARD_TOKENS = [
+	{
+		token: "[..]",
+		category: "generic",
+		multiline: false
+	},
+	{
+		token: "[??]",
+		category: "unknown",
+		multiline: false
+	},
+	{
+		token: /\.\.\.\n/,
+		category: "generic",
+		multiline: true
+	},
+	{
+		token: /\?\?\?\n/,
+		category: "unknown",
+		multiline: true
+	}
+];
+/**
+* Expand wildcards in expected output by replacing them with captured actual text.
+*
+* Only wildcards whose category is targeted by `level` are replaced; others are
+* left intact. Returns `null` if actual output doesn't match expected pattern.
+*/
+function expandExpectedOutput(expected, actual, context, level, customPatterns) {
+	const normalizedExpected = normalizeOutput(expected);
+	const normalizedActual = normalizeOutput(actual);
+	if (normalizedExpected === "" && normalizedActual === "") return {
+		expandedOutput: "",
+		captures: [],
+		expandedCount: 0
+	};
+	const result = matchAndCapture(actual, expected, context, customPatterns);
+	if (!result) return null;
+	let output = normalizedExpected;
+	let expandedCount = 0;
+	const tokenPositions = [];
+	for (const wt of WILDCARD_TOKENS) {
+		let searchFrom = 0;
+		if (typeof wt.token === "string") while (true) {
+			const pos = output.indexOf(wt.token, searchFrom);
+			if (pos === -1) break;
+			tokenPositions.push({
+				pos,
+				length: wt.token.length
+			});
+			searchFrom = pos + wt.token.length;
+		}
+		else {
+			const re = new RegExp(wt.token.source, "g");
+			let m;
+			while ((m = re.exec(output)) !== null) tokenPositions.push({
+				pos: m.index,
+				length: m[0].length
+			});
+		}
+	}
+	if (customPatterns) for (const name of Object.keys(customPatterns)) {
+		const placeholder = `[${name}]`;
+		let searchFrom = 0;
+		while (true) {
+			const pos = output.indexOf(placeholder, searchFrom);
+			if (pos === -1) break;
+			tokenPositions.push({
+				pos,
+				length: placeholder.length
+			});
+			searchFrom = pos + placeholder.length;
+		}
+	}
+	tokenPositions.sort((a, b) => a.pos - b.pos);
+	const replacements = tokenPositions.map((tp, i) => ({
+		...tp,
+		capture: result.captures[i]
+	}));
+	for (let i = replacements.length - 1; i >= 0; i--) {
+		const r = replacements[i];
+		if (shouldExpandCategory(r.capture.category, level)) {
+			const replacement = r.capture.captured;
+			output = output.slice(0, r.pos) + replacement + output.slice(r.pos + r.length);
+			expandedCount++;
+		}
+	}
+	return {
+		expandedOutput: output,
+		captures: result.captures,
+		expandedCount
+	};
+}
+/**
+* Expand wildcards in a test file in place.
+*
+* Uses the same reverse-order strategy as `updater.ts` to maintain correct
+* string offsets when modifying multiple blocks.
+*/
+async function expandTestFile(file, results, level, context, customPatterns) {
+	let content = file.rawContent;
+	const changes = [];
+	let totalExpanded = 0;
+	const resultByBlock = new Map(results.map((result) => [result.block, result]));
+	const blocksWithResults = [...file.blocks].map((block) => ({
+		block,
+		result: resultByBlock.get(block)
+	})).reverse();
+	for (const { block, result } of blocksWithResults) {
+		if (!result || !block.expectedOutput) continue;
+		const expansion = expandExpectedOutput(block.expectedOutput, result.actualOutput, context, level, customPatterns);
+		if (!expansion || expansion.expandedCount === 0) continue;
+		const fence = "`".repeat(/^(`+)/.exec(block.rawContent)?.[1]?.length ?? 3);
+		const commandLines = block.command.split("\n").map((line, i) => {
+			return i === 0 ? `$ ${line}` : `> ${line}`;
+		});
+		const lines = [`${fence}console`, ...commandLines];
+		const trimmedOutput = expansion.expandedOutput.trimEnd();
+		if (trimmedOutput) lines.push(trimmedOutput);
+		lines.push(`? ${block.expectedExitCode ?? result.actualExitCode}`, fence);
+		const newBlockContent = lines.join("\n");
+		const blockStart = content.indexOf(block.rawContent);
+		if (blockStart !== -1) {
+			content = content.slice(0, blockStart) + newBlockContent + content.slice(blockStart + block.rawContent.length);
+			changes.push(block.name ?? `Line ${block.lineNumber}`);
+			totalExpanded += expansion.expandedCount;
+		}
+	}
+	if (changes.length > 0) await (0, atomically.writeFile)(file.path, content);
+	return {
+		expanded: changes.length > 0,
+		expandedCount: totalExpanded,
+		changes
+	};
+}
+
+//#endregion
+//#region src/lib/yaml-utils.ts
+/**
+* Manual key order comparator for YAML `sortMapEntries`.
+*
+* Keys listed in `order` appear first (in that order); unlisted keys sort
+* to the end alphabetically. Adapted from tbd sorting patterns
+* (`ordering.manual`).
+*/
+function manualKeyOrder(order) {
+	const orderMap = new Map(order.map((key, index) => [key, index]));
+	return (a, b) => {
+		const indexA = orderMap.get(a.key.value);
+		const indexB = orderMap.get(b.key.value);
+		if (indexA === void 0 && indexB === void 0) return a.key.value.localeCompare(b.key.value);
+		if (indexA === void 0) return 1;
+		if (indexB === void 0) return -1;
+		return indexA - indexB;
+	};
+}
+const DEFAULT_YAML_LINE_WIDTH = 88;
+const YAML_STRINGIFY_OPTIONS = {
+	lineWidth: DEFAULT_YAML_LINE_WIDTH,
+	defaultStringType: "PLAIN",
+	defaultKeyType: "PLAIN"
+};
+function stringifyYaml(data, options) {
+	return (0, yaml.stringify)(data, {
+		...YAML_STRINGIFY_OPTIONS,
+		...options
+	});
+}
+
+//#endregion
+//#region src/lib/capture-log.ts
+const TOP_LEVEL_ORDER = manualKeyOrder(["generated", "files"]);
+const FILE_ORDER = manualKeyOrder(["path", "blocks"]);
+const BLOCK_ORDER = manualKeyOrder([
+	"name",
+	"command",
+	"expected_exit_code",
+	"actual_exit_code",
+	"expected_output",
+	"actual_output",
+	"captures",
+	"passed"
+]);
+const CAPTURE_ORDER = manualKeyOrder([
+	"category",
+	"name",
+	"multiline",
+	"matched"
+]);
+/**
+* Sort comparator for `yaml.stringify`'s `sortMapEntries`.
+*
+* Dispatches to the correct field ordering based on which keys are present,
+* since the `yaml` package calls this for every map node in the document.
+*/
+const BLOCK_KEYS = new Set([
+	"name",
+	"command",
+	"expected_exit_code",
+	"actual_exit_code",
+	"expected_output",
+	"actual_output",
+	"captures",
+	"passed"
+]);
+const CAPTURE_KEYS = new Set([
+	"category",
+	"name",
+	"multiline",
+	"matched"
+]);
+function captureLogSortMapEntries(a, b) {
+	const aKey = a.key.value;
+	const bKey = b.key.value;
+	if (aKey === "generated" || aKey === "files" || bKey === "generated" || bKey === "files") return TOP_LEVEL_ORDER(a, b);
+	if (aKey === "blocks" || bKey === "blocks") return FILE_ORDER(a, b);
+	if (BLOCK_KEYS.has(aKey) && BLOCK_KEYS.has(bKey)) return BLOCK_ORDER(a, b);
+	if (CAPTURE_KEYS.has(aKey) && CAPTURE_KEYS.has(bKey)) return CAPTURE_ORDER(a, b);
+	return aKey.localeCompare(bKey);
+}
+/**
+* Build the capture log document structure from test results.
+*
+* `customPatterns` can be a static object or a per-file callback.
+* Separated from `writeCaptureLog` for testability.
+*/
+function buildCaptureLogDoc(fileResults, matchContext, customPatterns) {
+	const files = fileResults.map((fr) => {
+		const ctx = matchContext(fr.file);
+		const patterns = typeof customPatterns === "function" ? customPatterns(fr.file) : customPatterns;
+		const blocks = fr.results.map((r) => {
+			const captures = (matchAndCapture(r.actualOutput, r.block.expectedOutput, ctx, patterns)?.captures ?? []).map((c) => ({
+				category: c.category,
+				...c.name ? { name: c.name } : {},
+				multiline: c.multiline,
+				matched: c.captured
+			}));
+			return {
+				name: r.block.name,
+				command: r.block.command,
+				expected_exit_code: r.block.expectedExitCode,
+				actual_exit_code: r.actualExitCode,
+				expected_output: r.block.expectedOutput,
+				actual_output: r.actualOutput,
+				captures,
+				passed: r.passed
+			};
+		});
+		return {
+			path: fr.file.path,
+			blocks
+		};
+	});
+	return {
+		generated: (/* @__PURE__ */ new Date()).toISOString(),
+		files
+	};
+}
+/**
+* Write a YAML capture log file recording wildcard captures and execution metadata.
+*/
+async function writeCaptureLog(path, fileResults, matchContext, customPatterns) {
+	await (0, atomically.writeFile)(path, "# tryscript capture log\n" + stringifyYaml(buildCaptureLogDoc(fileResults, matchContext, customPatterns), { sortMapEntries: captureLogSortMapEntries }));
+}
 
 //#endregion
 //#region src/index.ts
-const VERSION = "0.1.6";
+const VERSION = "0.1.7";
 
 //#endregion
 Object.defineProperty(exports, 'VERSION', {
@@ -607,6 +1033,12 @@ Object.defineProperty(exports, '__toESM', {
     return __toESM;
   }
 });
+Object.defineProperty(exports, 'buildCaptureLogDoc', {
+  enumerable: true,
+  get: function () {
+    return buildCaptureLogDoc;
+  }
+});
 Object.defineProperty(exports, 'cleanupExecutionContext', {
   enumerable: true,
   get: function () {
@@ -625,12 +1057,36 @@ Object.defineProperty(exports, 'defineConfig', {
     return defineConfig;
   }
 });
+Object.defineProperty(exports, 'expandExpectedOutput', {
+  enumerable: true,
+  get: function () {
+    return expandExpectedOutput;
+  }
+});
+Object.defineProperty(exports, 'expandTestFile', {
+  enumerable: true,
+  get: function () {
+    return expandTestFile;
+  }
+});
 Object.defineProperty(exports, 'loadConfig', {
   enumerable: true,
   get: function () {
     return loadConfig;
   }
 });
+Object.defineProperty(exports, 'manualKeyOrder', {
+  enumerable: true,
+  get: function () {
+    return manualKeyOrder;
+  }
+});
+Object.defineProperty(exports, 'matchAndCapture', {
+  enumerable: true,
+  get: function () {
+    return matchAndCapture;
+  }
+});
 Object.defineProperty(exports, 'matchOutput', {
   enumerable: true,
   get: function () {
@@ -673,4 +1129,22 @@ Object.defineProperty(exports, 'runBlock', {
     return runBlock;
   }
 });
-//# sourceMappingURL=src-1oEnK7GG.cjs.map
+Object.defineProperty(exports, 'shouldExpandCategory', {
+  enumerable: true,
+  get: function () {
+    return shouldExpandCategory;
+  }
+});
+Object.defineProperty(exports, 'stringifyYaml', {
+  enumerable: true,
+  get: function () {
+    return stringifyYaml;
+  }
+});
+Object.defineProperty(exports, 'writeCaptureLog', {
+  enumerable: true,
+  get: function () {
+    return writeCaptureLog;
+  }
+});
+//# sourceMappingURL=src-BIZMxxIt.cjs.map