@tailor-platform/sdk-codemod 0.3.0-next.0 → 0.3.0-next.2

package/dist/codemods/v2/cli-rename/scripts/transform.js

@@ -1,15 +1,377 @@
 import * as path from "pathe";
 //#region codemods/v2/cli-rename/scripts/transform.ts
 const COMMAND_RENAMES = [["crash-report", "crashreport"]];
-const COMMAND_PATTERN = new RegExp(`\\btailor-sdk(@[^\\s'"\`]+)?(\\s+)(${COMMAND_RENAMES.map(([from]) => from).join("|")})\\b`, "g");
+const OPTION_RENAMES = [["--machineuser", "--machine-user"]];
+const ARG_VALUE = `(?:[^\\s'"\`;&|]+|'[^']*'|"(?:(?:\\\\.)|[^"\\\\])*")`;
+const GLOBAL_ARG_PATTERN = `(?:(?:\\s+(?:--verbose|--json|-j))|(?:\\s+(?:--env-file|--env-file-if-exists|-e)(?:=${ARG_VALUE}|\\s+${ARG_VALUE})))*`;
+const TAILOR_BINARY = `(?<![\\w-])tailor-sdk(?:@[^\\s'"\`]+)?(?![\\w-])`;
+const COMMAND_PATTERN = new RegExp(`${TAILOR_BINARY}(${GLOBAL_ARG_PATTERN}\\s+)(${COMMAND_RENAMES.map(([from]) => from).join("|")})\\b`, "g");
+const TAILOR_BINARY_PATTERN = new RegExp(TAILOR_BINARY, "g");
 const COMMAND_MAP = new Map(COMMAND_RENAMES);
-function replaceAll(value) {
-	return value.replace(COMMAND_PATTERN, (_match, ver, sep, cmd) => `tailor-sdk${ver ?? ""}${sep}${COMMAND_MAP.get(cmd) ?? cmd}`);
+function isOptionBoundaryChar(value) {
+	return value === void 0 || !/[\w-]/.test(value);
 }
-function transformText(source) {
-	if (!COMMAND_PATTERN.test(source)) return null;
-	COMMAND_PATTERN.lastIndex = 0;
-	const updated = replaceAll(source);
+function findInlineCodeSpanEnd(source, start) {
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	if ([...source.slice(lineStart, start).matchAll(/`/g)].length % 2 === 0) return void 0;
+	const codeSpanEnd = source.indexOf("`", start);
+	return codeSpanEnd === -1 ? void 0 : codeSpanEnd;
+}
+function findEnclosingLineQuoteEnd(source, start) {
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	const lineEnd = source.indexOf("\n", start);
+	const limit = lineEnd === -1 ? source.length : lineEnd;
+	let quote = null;
+	for (let index = lineStart; index < start; index += 1) {
+		const ch = source[index];
+		if (quote !== null) {
+			if (ch === "\\" && quote === "\"" && index + 1 < start) {
+				index += 1;
+				continue;
+			}
+			if (ch === quote) quote = null;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") quote = ch;
+	}
+	if (quote === null) return void 0;
+	for (let index = start; index < limit; index += 1) {
+		const ch = source[index];
+		if (ch === "\\" && quote === "\"" && index + 1 < limit) {
+			index += 1;
+			continue;
+		}
+		if (ch === quote) return index;
+	}
+}
+function lineIndent(line) {
+	return line.match(/^ */)?.[0].length ?? 0;
+}
+function isFoldedScalarHeader(line) {
+	return /^\s*(?:-\s*)?[^#\n]*:\s*>[+-]?(?:\s*(?:#.*)?)?$/.test(line);
+}
+function findFoldedYamlRanges(source) {
+	const ranges = [];
+	const lines = source.match(/^.*(?:\n|$)/gm) ?? [];
+	let offset = 0;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const body = line.replace(/\r?\n$/, "");
+		offset += line.length;
+		if (!isFoldedScalarHeader(body)) continue;
+		const baseIndent = lineIndent(body);
+		let rangeStart;
+		let rangeEnd;
+		let cursor = offset;
+		for (let nextIndex = index + 1; nextIndex < lines.length; nextIndex += 1) {
+			const nextLine = lines[nextIndex];
+			const nextBody = nextLine.replace(/\r?\n$/, "");
+			const trimmed = nextBody.trim();
+			const indent = lineIndent(nextBody);
+			if (trimmed !== "" && indent <= baseIndent) break;
+			if (trimmed === "") {
+				if (rangeStart !== void 0 && rangeEnd !== void 0) {
+					ranges.push({
+						start: rangeStart,
+						end: rangeEnd
+					});
+					rangeStart = void 0;
+					rangeEnd = void 0;
+				}
+			} else {
+				rangeStart ??= cursor;
+				rangeEnd = cursor + nextLine.length;
+			}
+			cursor += nextLine.length;
+		}
+		if (rangeStart !== void 0 && rangeEnd !== void 0) ranges.push({
+			start: rangeStart,
+			end: rangeEnd
+		});
+	}
+	return ranges;
+}
+function findMarkdownFencedCodeRanges(source) {
+	const ranges = [];
+	const lines = source.match(/^.*(?:\n|$)/gm) ?? [];
+	let offset = 0;
+	let open;
+	for (const line of lines) {
+		const body = line.replace(/\r?\n$/, "");
+		if (open) {
+			const marker = body.match(/^ {0,3}(`{3,}|~{3,})\s*$/)?.[1];
+			if (marker && marker[0] === open.char && marker.length >= open.length) {
+				ranges.push({
+					start: open.start,
+					end: offset
+				});
+				open = void 0;
+			}
+		} else {
+			const marker = body.match(/^ {0,3}(`{3,}|~{3,}).*$/)?.[1];
+			if (marker) open = {
+				char: marker[0],
+				length: marker.length,
+				start: offset + line.length
+			};
+		}
+		offset += line.length;
+	}
+	if (open) ranges.push({
+		start: open.start,
+		end: source.length
+	});
+	return ranges;
+}
+function isCommandSeparator(source, index) {
+	const ch = source[index];
+	const prev = source[index - 1];
+	if (prev === "\\") return false;
+	if (ch === "&") {
+		const next = source[index + 1];
+		if (prev === ">" || prev === "<" || next === ">") return false;
+	}
+	return ch === ";" || ch === "&" || ch === "|";
+}
+function startsCommandSubstitution(source, index) {
+	return source[index] === "$" && source[index + 1] === "(" && source[index - 1] !== "\\";
+}
+function findCommandSubstitutionEnd(source, start) {
+	let depth = 1;
+	let index = start + 2;
+	let quote = null;
+	while (index < source.length) {
+		const ch = source[index];
+		if (quote !== null) {
+			if (quote.escaped) {
+				if (ch === "\\" && source[index + 1] === quote.char) {
+					quote = null;
+					index += 2;
+					continue;
+				}
+				index += 1;
+				continue;
+			}
+			if (quote.char === "\"" && startsCommandSubstitution(source, index)) {
+				depth += 1;
+				index += 2;
+				continue;
+			}
+			if (ch === "\\" && quote.char === "\"" && index + 1 < source.length) {
+				index += 2;
+				continue;
+			}
+			if (ch === quote.char) quote = null;
+			index += 1;
+			continue;
+		}
+		if (ch === "\\" && source[index + 1] === "\"") {
+			quote = {
+				char: "\"",
+				escaped: true
+			};
+			index += 2;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = {
+				char: ch,
+				escaped: false
+			};
+			index += 1;
+			continue;
+		}
+		if (startsCommandSubstitution(source, index)) {
+			depth += 1;
+			index += 2;
+			continue;
+		}
+		if (ch === ")") {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+		index += 1;
+	}
+}
+function findContainingRange(ranges, index) {
+	return ranges?.find((range) => range.start <= index && index < range.end);
+}
+function findTailorCommandEnd(source, start, foldedYamlRanges, markdownFencedCodeRanges) {
+	const inlineCodeSpanEnd = findInlineCodeSpanEnd(source, start);
+	const enclosingLineQuoteEnd = findEnclosingLineQuoteEnd(source, start);
+	const limit = Math.min(inlineCodeSpanEnd ?? source.length, enclosingLineQuoteEnd ?? source.length);
+	const foldedYamlRange = findContainingRange(foldedYamlRanges, start);
+	const markdownFencedCodeRange = findContainingRange(markdownFencedCodeRanges, start);
+	const delimitedRange = foldedYamlRange ?? markdownFencedCodeRange;
+	const commandLimit = delimitedRange ? Math.min(limit, delimitedRange.end) : limit;
+	let quote = null;
+	let end = start;
+	while (end < commandLimit) {
+		const ch = source[end];
+		if (quote !== null) {
+			if (quote.escaped) {
+				if (ch === "\\" && source[end + 1] === quote.char) {
+					quote = null;
+					end += 2;
+					continue;
+				}
+				end += 1;
+				continue;
+			}
+			if (quote.char === "\"" && startsCommandSubstitution(source, end)) {
+				const substitutionEnd = findCommandSubstitutionEnd(source, end);
+				if (substitutionEnd !== void 0) {
+					end = substitutionEnd + 1;
+					continue;
+				}
+			}
+			if (ch === "\\" && quote.char === "\"" && end + 1 < commandLimit) {
+				end += 2;
+				continue;
+			}
+			if (ch === quote.char) quote = null;
+			end += 1;
+			continue;
+		}
+		if (ch === "\\" && source[end + 1] === "\"") {
+			quote = {
+				char: "\"",
+				escaped: true
+			};
+			end += 2;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = {
+				char: ch,
+				escaped: false
+			};
+			end += 1;
+			continue;
+		}
+		if (startsCommandSubstitution(source, end)) {
+			const substitutionEnd = findCommandSubstitutionEnd(source, end);
+			if (substitutionEnd !== void 0) {
+				end = substitutionEnd + 1;
+				continue;
+			}
+		}
+		const prev = source[end - 1];
+		if (ch === ")") break;
+		if (isCommandSeparator(source, end)) break;
+		if (ch === "\n" && prev !== "\\" && !foldedYamlRange) break;
+		end += 1;
+	}
+	return end;
+}
+function isDelimitedCommandContext(source, start, foldedYamlRanges, markdownFencedCodeRanges) {
+	return findInlineCodeSpanEnd(source, start) !== void 0 || findEnclosingLineQuoteEnd(source, start) !== void 0 || findContainingRange(foldedYamlRanges, start) !== void 0 || findContainingRange(markdownFencedCodeRanges, start) !== void 0;
+}
+function findOptionRename(command, index) {
+	return OPTION_RENAMES.find(([from]) => command.startsWith(from, index) && isOptionBoundaryChar(command[index - 1]) && isOptionBoundaryChar(command[index + from.length]));
+}
+function replaceOptionsInCommand(command) {
+	let updated = "";
+	let index = 0;
+	let quote = null;
+	while (index < command.length) {
+		const ch = command[index];
+		if (quote !== null) {
+			if (quote.char === "\"" && startsCommandSubstitution(command, index)) {
+				const substitutionEnd = findCommandSubstitutionEnd(command, index);
+				if (substitutionEnd !== void 0) {
+					updated += "$(";
+					updated += replaceAll(command.slice(index + 2, substitutionEnd));
+					updated += ")";
+					index = substitutionEnd + 1;
+					continue;
+				}
+			}
+			updated += ch;
+			if (quote.escaped) {
+				if (ch === "\\" && command[index + 1] === quote.char) {
+					index += 1;
+					updated += command[index];
+					quote = null;
+				}
+			} else if (ch === "\\" && quote.char === "\"" && index + 1 < command.length) {
+				index += 1;
+				updated += command[index];
+			} else if (ch === quote.char) quote = null;
+			index += 1;
+			continue;
+		}
+		if (ch === "\\" && command[index + 1] === "\"") {
+			quote = {
+				char: "\"",
+				escaped: true
+			};
+			updated += ch;
+			index += 1;
+			updated += command[index];
+			index += 1;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = {
+				char: ch,
+				escaped: false
+			};
+			updated += ch;
+			index += 1;
+			continue;
+		}
+		if (startsCommandSubstitution(command, index)) {
+			const substitutionEnd = findCommandSubstitutionEnd(command, index);
+			if (substitutionEnd !== void 0) {
+				updated += "$(";
+				updated += replaceAll(command.slice(index + 2, substitutionEnd));
+				updated += ")";
+				index = substitutionEnd + 1;
+				continue;
+			}
+		}
+		const rename = findOptionRename(command, index);
+		if (rename) {
+			updated += rename[1];
+			index += rename[0].length;
+			continue;
+		}
+		updated += ch;
+		index += 1;
+	}
+	return updated;
+}
+function replaceOptionsInTailorCommands(source, foldedYamlRanges, requireDelimitedContext = false, markdownFencedCodeRanges) {
+	let updated = "";
+	let cursor = 0;
+	TAILOR_BINARY_PATTERN.lastIndex = 0;
+	for (;;) {
+		const match = TAILOR_BINARY_PATTERN.exec(source);
+		if (!match) break;
+		const start = match.index;
+		if (start < cursor) continue;
+		if (requireDelimitedContext && !isDelimitedCommandContext(source, start, foldedYamlRanges, markdownFencedCodeRanges)) {
+			TAILOR_BINARY_PATTERN.lastIndex = start + match[0].length;
+			continue;
+		}
+		const end = findTailorCommandEnd(source, start, foldedYamlRanges, markdownFencedCodeRanges);
+		updated += source.slice(cursor, start);
+		updated += replaceOptionsInCommand(source.slice(start, end));
+		cursor = end;
+		TAILOR_BINARY_PATTERN.lastIndex = end;
+	}
+	return updated + source.slice(cursor);
+}
+function replaceAll(value, parseFoldedYaml = false, requireDelimitedContext = false, parseMarkdownFencedCode = false) {
+	const updated = value.replace(COMMAND_PATTERN, (match, _prefix, cmd) => `${match.slice(0, -cmd.length)}${COMMAND_MAP.get(cmd) ?? cmd}`);
+	return replaceOptionsInTailorCommands(updated, parseFoldedYaml ? findFoldedYamlRanges(updated) : void 0, requireDelimitedContext, parseMarkdownFencedCode ? findMarkdownFencedCodeRanges(updated) : void 0);
+}
+function transformText(source, filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	const isYaml = ext === ".yml" || ext === ".yaml";
+	const isMarkdown = ext === ".md";
+	const updated = replaceAll(source, isYaml, isMarkdown, isMarkdown);
 	return updated === source ? null : updated;
 }
 function transformPackageJson(source) {
@@ -35,20 +397,17 @@ function transformPackageJson(source) {
 }
 /**
 * Apply v2 CLI naming conventions: multi-word commands collapse into a single
-* word (`crash-report` → `crashreport`). Optional `@version` pins on the binary
-* (`tailor-sdk@latest`) are preserved.
+* word (`crash-report` → `crashreport`), and legacy option spellings are
+* rewritten to kebab-case (`--machineuser` → `--machine-user`). Optional
+* `@version` pins on the binary (`tailor-sdk@latest`) are preserved.
 *
-* Long options (`--executionId`, `--executorName`, `--jobId`) and the
-* positional argument keys with the same names are intentionally not rewritten:
-* those tokens are positional in the SDK CLI and never appear as long flags in
-* user scripts, so a transform here would have no real-world target.
 * @param source - File contents
 * @param filePath - Absolute path to the file (used to dispatch package.json vs text)
 * @returns Transformed source or null when nothing matched.
 */
 function transform(source, filePath) {
 	if (path.extname(filePath).toLowerCase() === ".json") return transformPackageJson(source);
-	return transformText(source);
+	return transformText(source, filePath);
 }
 //#endregion
 export { transform as default };

package/dist/codemods/v2/execute-script-arg/scripts/transform.js

@@ -0,0 +1,60 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/execute-script-arg/scripts/transform.ts
+const NEEDLE = "executeScript";
+function quickFilter(source) {
+	return source.includes(NEEDLE) && source.includes("JSON.stringify");
+}
+function pairKeyText(pair) {
+	const key = pair.children()[0];
+	if (!key) return null;
+	return key.text().replace(/^['"]|['"]$/g, "");
+}
+/**
+* True when `stringifyCall` is the value of a top-level `arg:` property in the
+* object literal passed directly to `executeScript(...)`. The chain checked is
+* `JSON.stringify(...)` → pair (`arg:`) → object → arguments → `executeScript`
+* call, so a nested `arg:` (e.g. `executeScript({ opts: { arg: ... } })`) or an
+* unrelated `JSON.stringify` is left untouched.
+*/
+function isExecuteScriptArg(stringifyCall) {
+	const pair = stringifyCall.parent();
+	if (!pair || pair.kind() !== "pair") return false;
+	if (pairKeyText(pair) !== "arg") return false;
+	const obj = pair.parent();
+	if (!obj || obj.kind() !== "object") return false;
+	const args = obj.parent();
+	if (!args || args.kind() !== "arguments") return false;
+	const call = args.parent();
+	if (!call || call.kind() !== "call_expression") return false;
+	const callee = call.children()[0];
+	return !!callee && callee.text() === NEEDLE;
+}
+/**
+* Rewrite `executeScript({ ..., arg: JSON.stringify(X), ... })` to
+* `executeScript({ ..., arg: X, ... })`.
+*
+* In v2 the `executeScript` `arg` option takes a JSON-serializable value and
+* serializes it internally, so a pre-stringified argument double-encodes. Only
+* the literal `arg: JSON.stringify(<single expr>)` form is rewritten; indirect
+* forms (a stringified value held in a variable, `JSON.stringify(x, null, 2)`,
+* etc.) are left for manual migration.
+* @param source - File contents
+* @param _filePath - Absolute path to the file (kept for the runner signature)
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, _filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
+	const edits = [];
+	for (const match of root.findAll({ rule: { pattern: "JSON.stringify($X)" } })) {
+		if (!isExecuteScriptArg(match)) continue;
+		const inner = match.getMatch("X");
+		if (!inner) continue;
+		edits.push(match.replace(inner.text()));
+	}
+	if (edits.length === 0) return null;
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+//#endregion
+export { transform as default };