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

package/dist/codemods/v2/runtime-globals-opt-in/scripts/transform.js

@@ -0,0 +1,103 @@
+import { n as findImportStatements, r as importBindings, s as localDeclarationNames, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-Bfn39biW.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/runtime-globals-opt-in/scripts/transform.ts
+const RUNTIME_MODULE = "@tailor-platform/sdk/runtime";
+const TAILOR_IDP_CLIENT = "tailor.idp.Client";
+const NON_ARGUMENT_KINDS = /* @__PURE__ */ new Set([
+	"(",
+	")",
+	",",
+	"comment"
+]);
+function quickFilter(source) {
+	return source.includes(TAILOR_IDP_CLIENT);
+}
+function sourceLang(filePath, source) {
+	return filePath.endsWith(".tsx") || filePath.endsWith(".jsx") || source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function runtimeIdpLocalName(imports) {
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) if (binding.source === RUNTIME_MODULE && binding.importedName === "idp" && !binding.typeOnly) return binding.localName;
+	return null;
+}
+function isRuntimeIdpBinding(binding) {
+	return binding.source === RUNTIME_MODULE && binding.importedName === "idp";
+}
+function hasCollision(imports, localNames, idpLocal, injectingNewIdpName) {
+	if (localNames.has("tailor") || injectingNewIdpName && localNames.has("idp") || localNames.has(idpLocal)) return true;
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) {
+		if (binding.localName === "tailor") return true;
+		if (binding.localName !== "idp") continue;
+		if (isRuntimeIdpBinding(binding)) continue;
+		return true;
+	}
+	return false;
+}
+function isDirectiveStatement(node) {
+	return node.kind() === "expression_statement" && node.children()[0]?.kind() === "string";
+}
+function importInsertionIndex(root, imports, source) {
+	const lastImport = imports.at(-1);
+	if (lastImport) return lastImport.range().end.index;
+	let pos = 0;
+	if (source.startsWith("#!")) {
+		const newlineIndex = source.indexOf("\n");
+		pos = newlineIndex === -1 ? source.length : newlineIndex + 1;
+	}
+	for (const child of root.children()) {
+		if (child.range().start.index < pos) continue;
+		if (child.kind() === "comment") {
+			pos = child.range().end.index;
+			continue;
+		}
+		if (!isDirectiveStatement(child)) break;
+		pos = child.range().end.index;
+	}
+	return pos;
+}
+function buildAddRuntimeImportEdit(root, source, imports) {
+	return buildAddNamedImportEdit({
+		importName: "idp",
+		imports,
+		insertionIndex: importInsertionIndex,
+		moduleName: RUNTIME_MODULE,
+		root,
+		source
+	});
+}
+function argumentExpressions(args) {
+	return args.children().filter((child) => !NON_ARGUMENT_KINDS.has(child.kind()));
+}
+function hasConstructorArguments(newExpression) {
+	const args = newExpression.field("arguments");
+	return args ? argumentExpressions(args).length > 0 : false;
+}
+function findTailorIdpClientConstructors(root) {
+	return root.findAll({ rule: { kind: "new_expression" } }).filter(hasConstructorArguments).map((node) => node.field("constructor")).filter((node) => node?.text() === TAILOR_IDP_CLIENT);
+}
+/**
+* Rewrite direct `new tailor.idp.Client(...)` calls to the typed runtime
+* wrapper. Files with local `tailor` or conflicting `idp` bindings are left
+* unchanged for the runtime-globals review prompt.
+* @param source - File contents
+* @param filePath - Absolute path to the file
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(sourceLang(filePath, source), source).root();
+	const constructors = findTailorIdpClientConstructors(root);
+	if (constructors.length === 0) return null;
+	const imports = findImportStatements(root);
+	const existingIdpLocal = runtimeIdpLocalName(imports);
+	const idpLocal = existingIdpLocal ?? "idp";
+	if (hasCollision(imports, localDeclarationNames(root), idpLocal, existingIdpLocal === null)) return null;
+	const edits = constructors.map((constructor) => constructor.replace(`${idpLocal}.Client`));
+	if (!existingIdpLocal) {
+		if (filePath.endsWith(".cts")) return null;
+		edits.push(buildAddRuntimeImportEdit(root, source, imports));
+	}
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/sdk-skills-shim/scripts/transform.js

@@ -1,7 +1,7 @@
 import * as path from "pathe";
 //#region codemods/v2/sdk-skills-shim/scripts/transform.ts
 const SHIM_PATTERN = /\btailor-sdk-skills(?:@[^\s'"`]+)?(?:[ \t]+install)?\b(?!-)/g;
-const REPLACEMENT = "tailor-sdk skills install";
+const REPLACEMENT = "tailor skills add";
 function replaceShim(value) {
 	return value.replace(SHIM_PATTERN, REPLACEMENT);
 }
@@ -34,10 +34,10 @@ function transformPackageJson(source) {
 	return JSON.stringify(parsed, null, 2) + trailing;
 }
 /**
-* Replace `tailor-sdk-skills` invocations with `tailor-sdk skills install`.
+* Replace `tailor-sdk-skills` invocations with `tailor skills add`.
 *
 * The standalone `tailor-sdk-skills` binary is removed in v2; users must call
-* the subcommand on the main `tailor-sdk` CLI instead.
+* the subcommand on the main `tailor` CLI instead.
 * @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.

package/dist/codemods/v2/tailor-output-ignore-dir/scripts/transform.js

@@ -0,0 +1,14 @@
+//#region codemods/v2/tailor-output-ignore-dir/scripts/transform.ts
+const GENERATED_DIR_IGNORE_ENTRY_RE = /^(!?\/?)\.tailor-sdk(\/?)([ \t]*)$/gm;
+/**
+* Rewrite exact ignore-file entries for the generated SDK output directory.
+* @param source - File contents
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source) {
+	if (!source.includes(".tailor-sdk")) return null;
+	const updated = source.replace(GENERATED_DIR_IGNORE_ENTRY_RE, (_match, prefix, slash, trailingWhitespace) => `${prefix}.tailor${slash}${trailingWhitespace}`);
+	return updated === source ? null : updated;
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/wait-point-rename/scripts/transform.js

@@ -0,0 +1,126 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/wait-point-rename/scripts/transform.ts
+const SDK_MODULE = "@tailor-platform/sdk";
+const RENAMES = {
+	defineWaitPoint: "createWaitPoint",
+	defineWaitPoints: "createWaitPoints"
+};
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+/**
+* Rename `defineWaitPoint` and `defineWaitPoints` imported from `@tailor-platform/sdk`
+* to `createWaitPoint` and `createWaitPoints`, updating both the import specifiers
+* and all usages in the file body.
+* @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 (!Object.keys(RENAMES).some((name) => source.includes(name))) return null;
+	if (!source.includes(SDK_MODULE)) return null;
+	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
+	const edits = [];
+	const needsBodyRename = /* @__PURE__ */ new Set();
+	const importStmts = root.findAll({ rule: {
+		kind: "import_statement",
+		has: {
+			kind: "string",
+			regex: `^["']${SDK_MODULE}["']$`
+		}
+	} });
+	for (const importStmt of importStmts) {
+		const specs = importStmt.findAll({ rule: { kind: "import_specifier" } });
+		for (const spec of specs) {
+			const idents = spec.children().filter((c) => c.kind() === "identifier");
+			if (idents.length === 0) continue;
+			const importedName = idents[0].text();
+			const newName = RENAMES[importedName];
+			if (!newName) continue;
+			const isAliased = idents.length > 1;
+			edits.push(idents[0].replace(newName));
+			if (!isAliased) needsBodyRename.add(importedName);
+		}
+	}
+	if (edits.length === 0) return null;
+	if (needsBodyRename.size > 0) {
+		const shadowedRanges = /* @__PURE__ */ new Map();
+		const addShadowedRange = (name, scopeNode) => {
+			const r = scopeNode.range();
+			if (!shadowedRanges.has(name)) shadowedRanges.set(name, []);
+			shadowedRanges.get(name).push({
+				start: r.start.index,
+				end: r.end.index
+			});
+		};
+		const localDecls = root.findAll({ rule: { any: [{ kind: "function_declaration" }, { kind: "variable_declarator" }] } });
+		for (const decl of localDecls) {
+			if (isInsideImportStatement(decl)) continue;
+			const nameChild = decl.children().filter((c) => c.kind() === "identifier").find((c) => needsBodyRename.has(c.text())) ?? decl.children().find((c) => c.kind() === "object_pattern")?.children().find((c) => c.kind() === "shorthand_property_identifier_pattern" && needsBodyRename.has(c.text()));
+			if (!nameChild || !needsBodyRename.has(nameChild.text())) continue;
+			let scopeNode = root;
+			let p = decl.parent();
+			while (p) {
+				const k = p.kind();
+				if (k === "statement_block" || k === "program" || k === "for_statement" || k === "for_in_statement") {
+					scopeNode = p;
+					break;
+				}
+				p = p.parent();
+			}
+			addShadowedRange(nameChild.text(), scopeNode);
+		}
+		const paramNodes = root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } });
+		for (const param of paramNodes) {
+			if (isInsideImportStatement(param)) continue;
+			const nameChild = param.children().flatMap((c) => c.kind() === "rest_pattern" ? c.children().filter((cc) => cc.kind() === "identifier") : c.kind() === "identifier" ? [c] : []).find((c) => needsBodyRename.has(c.text()));
+			if (!nameChild) continue;
+			let scopeNode = root;
+			let p = param.parent();
+			while (p) {
+				const k = p.kind();
+				if (k === "formal_parameters") {
+					p = p.parent();
+					continue;
+				}
+				if (k === "function_declaration" || k === "function_expression" || k === "arrow_function" || k === "method_definition") {
+					scopeNode = p;
+					break;
+				}
+				break;
+			}
+			addShadowedRange(nameChild.text(), scopeNode);
+		}
+		const forInStmts = root.findAll({ rule: { kind: "for_in_statement" } });
+		for (const stmt of forInStmts) {
+			const children = stmt.children();
+			const keywordIdx = children.findIndex((c) => c.kind() === "of" || c.kind() === "in");
+			if (keywordIdx < 0) continue;
+			for (let i = 0; i < keywordIdx; i++) {
+				const child = children[i];
+				if (child.kind() === "identifier" && needsBodyRename.has(child.text())) addShadowedRange(child.text(), stmt);
+			}
+		}
+		const renameNode = (node) => {
+			const name = node.text();
+			if (!needsBodyRename.has(name)) return;
+			if (isInsideImportStatement(node)) return;
+			const ranges = shadowedRanges.get(name);
+			if (ranges) {
+				const pos = node.range().start.index;
+				if (ranges.some((r) => pos >= r.start && pos < r.end)) return;
+			}
+			edits.push(node.replace(RENAMES[name]));
+		};
+		for (const ident of root.findAll({ rule: { kind: "identifier" } })) renameNode(ident);
+		for (const prop of root.findAll({ rule: { kind: "shorthand_property_identifier" } })) renameNode(prop);
+	}
+	return root.commitEdits(edits);
+}
+//#endregion
+export { transform as default };