@tailor-platform/sdk-codemod 0.3.8 → 0.4.0-next.10

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/seed-exec-to-cli-plugin/scripts/transform.js

@@ -0,0 +1,115 @@
+import * as path from "pathe";
+//#region codemods/v2/seed-exec-to-cli-plugin/scripts/transform.ts
+const NODE_BINARY = "(?<![\\w.-])node(?![\\w-])";
+const ARG_VALUE = `(?:[^\\s'"\`;&|]+|'[^']*'|"(?:(?:\\\\.)|[^"\\\\])*")`;
+const SPACE = String.raw`(?:[^\S\n\r]|\\\r?\n)+`;
+const VALUE_NODE_FLAG = "(?:--env-file|--env-file-if-exists|--import|--require|-r)";
+const BOOLEAN_NODE_FLAG = "(?:--[^\\s'\"`;&|]+|-[^\\s'\"`;&|=-][^\\s'\"`;&|=]*)";
+const NODE_FLAGS = `(?:(?:${SPACE}${VALUE_NODE_FLAG}(?:=${ARG_VALUE}|${SPACE}${ARG_VALUE}))|(?:${SPACE}${BOOLEAN_NODE_FLAG}))*`;
+const RUNNER_PATH = `(?:[\\w.@~-]+/)+exec\\.mjs`;
+const RUNNER_PATTERN = new RegExp(`${NODE_BINARY}(${NODE_FLAGS})${SPACE}(['"]?)(?:\\./)?${RUNNER_PATH}\\2(${SPACE}validate(?![-\\w=.:/]))?`, "g");
+const FORK_PATTERN = /(?<![\w.$])fork\s*\(/;
+const FORK_RUNNER_PATTERN = new RegExp(`${FORK_PATTERN.source}\\s*(['"\`])${RUNNER_PATH}\\1`, "gs");
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const NODE_FLAG_PATTERN = new RegExp(`(${VALUE_NODE_FLAG})(?:=(${ARG_VALUE})|${SPACE}(${ARG_VALUE}))|(${BOOLEAN_NODE_FLAG})`, "g");
+const ENV_FILE_FLAG = /^--env-file(?:-if-exists)?$/;
+const RUNNER_PREFIX_PATTERN = new RegExp(`(?<![\\w.-])(?:pnpm|npm|yarn|bunx|bun|npx)(?:${SPACE}(?:run|exec|dlx))?${SPACE}$`);
+const RUNNER_PREFIX_WINDOW = 64;
+/** Translate the leading `node` flags into flags the CLI command accepts. */
+function carriedOverFlags(nodeFlags) {
+	return [...nodeFlags.matchAll(NODE_FLAG_PATTERN)].filter((match) => match[1] != null && ENV_FILE_FLAG.test(match[1])).map((match) => ` ${match[1]} ${match[2] ?? match[3]}`).join("");
+}
+/**
+* Rewrite runner invocations. The runner spells validation as its first
+* positional argument, so a consumed `validate` selects the subcommand.
+*/
+function rewrite(value, prefix = "") {
+	return value.replace(RUNNER_PATTERN, (_match, nodeFlags, _quote, validate, offset) => {
+		const command = validate ? "validate" : "apply";
+		const before = value.slice(Math.max(0, offset - RUNNER_PREFIX_WINDOW), offset);
+		return `${RUNNER_PREFIX_PATTERN.test(before) ? "" : prefix}tailor seed ${command}${carriedOverFlags(nodeFlags)}`;
+	});
+}
+function transformText(source) {
+	const updated = rewrite(source);
+	return updated === source ? null : updated;
+}
+/**
+* Source files reach the plugin through a package runner rather than the bare
+* binary, since the plugin executable is resolved from the project's
+* node_modules rather than the PATH.
+*/
+function transformSourceText(source) {
+	const updated = rewrite(source, "npx ");
+	if (FORK_PATTERN.test(source) && updated.includes("exec.mjs")) return null;
+	return updated === source ? null : updated;
+}
+function transformPackageJson(source) {
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch {
+		return null;
+	}
+	const scripts = parsed.scripts;
+	if (typeof scripts !== "object" || scripts == null || Array.isArray(scripts)) return null;
+	let modified = false;
+	for (const [name, value] of Object.entries(scripts)) {
+		if (typeof value !== "string") continue;
+		const updated = rewrite(value);
+		if (updated !== value) {
+			scripts[name] = updated;
+			modified = true;
+		}
+	}
+	if (!modified) return null;
+	const trailing = source.endsWith("\n") ? "\n" : "";
+	return JSON.stringify(parsed, null, 2) + trailing;
+}
+/**
+* Rewrite generated seed runner invocations to the `tailor seed` CLI plugin.
+* @param source - File contents
+* @param filePath - Absolute path to the file (used to dispatch package.json vs source vs text)
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, filePath) {
+	if (!source.includes("exec.mjs")) return null;
+	const ext = path.extname(filePath).toLowerCase();
+	if (ext === ".json") return transformPackageJson(source);
+	if (SOURCE_EXTENSIONS.has(ext)) return transformSourceText(source);
+	return transformText(source);
+}
+/**
+* Report `fork()` call sites the transform declined, so the migration surfaces
+* the async-plumbing rewrite instead of silently leaving a stale invocation.
+* @param source - Post-transform file contents
+* @param filePath - Absolute path to the file
+* @param relativePath - Path relative to the transformed project root
+* @returns Locations that need manual migration.
+*/
+function reviewFindings(source, filePath, relativePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	if (!SOURCE_EXTENSIONS.has(ext)) return [];
+	if (!source.includes("exec.mjs") || !FORK_PATTERN.test(source)) return [];
+	const lines = source.split(/\r\n|\n|\r/);
+	return [...source.matchAll(FORK_RUNNER_PATTERN)].map((match) => {
+		const index = source.slice(0, match.index).split(/\r\n|\n|\r/).length - 1;
+		return {
+			file: relativePath,
+			line: index + 1,
+			message: "Replace the fork()-based seed runner call with execSync(\"npx tailor seed apply\"), forwarding env/stdio, and unwind the surrounding await/Promise plumbing.",
+			excerpt: lines[index].trim()
+		};
+	});
+}
+//#endregion
+export { transform as default, reviewFindings };

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/tailordb-namespace/scripts/transform.js

@@ -6,10 +6,11 @@ const MEMBER_GROUP = [
 ].join("|");
 const PATTERN = new RegExp(String.raw`\bTailordb\.(${MEMBER_GROUP})\b`, "g");
 /**
-* Rewrite references to the deprecated capital-cased `Tailordb` ambient
-* namespace to the new lowercase `tailordb` namespace. The capital-cased
-* namespace was inherited from `@tailor-platform/function-types`; the SDK
-* keeps it as a `@deprecated` alias in v1 and removes it in v2.
+* Rewrite references to the capital-cased `Tailordb` ambient namespace to the
+* lowercase `tailordb` namespace. The capital-cased namespace was inherited
+* from `@tailor-platform/function-types`; the SDK kept it as a `@deprecated`
+* alias in v1 and removed it in v2, leaving only the lowercase `tailordb.*`
+* namespace exposed by `@tailor-platform/sdk/runtime/globals`.
 *
 * Only the known type-only members (`QueryResult`, `CommandType`, `Client`)
 * are rewritten so that unrelated user-defined symbols sharing the

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 };

package/dist/codemods/v2/workflow-trigger-rename/scripts/transform.js

@@ -0,0 +1,123 @@
+import { c as localDeclarationNames, i as importBindings, r as findImportStatements } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/workflow-trigger-rename/scripts/transform.ts
+const RENAMES = {
+	triggerWorkflow: "startWorkflow",
+	triggerJobFunction: "execJobFunction",
+	resumeWorkflow: "resumeWorkflowExecution"
+};
+const WORKFLOW_MODULE_SOURCES = /* @__PURE__ */ new Set(["@tailor-platform/sdk/runtime", "@tailor-platform/sdk/runtime/workflow"]);
+function quickFilter(source) {
+	return Object.keys(RENAMES).some((name) => source.includes(name));
+}
+function sourceLang(filePath, source) {
+	const lower = filePath.toLowerCase();
+	if (lower.endsWith(".tsx") || lower.endsWith(".jsx")) return Lang.Tsx;
+	return source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript;
+}
+function collectWorkflowLocals(root, imports) {
+	const locals = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) if (binding.importedName === "workflow" && WORKFLOW_MODULE_SOURCES.has(binding.source)) locals.add(binding.localName);
+	const declaredNames = localDeclarationNames(root);
+	for (const name of locals) if (declaredNames.has(name)) locals.delete(name);
+	return locals;
+}
+function tailorIsAmbientGlobal(root, imports) {
+	if (localDeclarationNames(root).has("tailor")) return false;
+	return !imports.some((stmt) => importBindings(stmt).some((b) => b.localName === "tailor"));
+}
+function isAmbientTailorWorkflow(object) {
+	if (!object || object.kind() !== "member_expression") return false;
+	const base = object.field("object");
+	const property = object.field("property");
+	return base?.kind() === "identifier" && base.text() === "tailor" && property?.text() === "workflow";
+}
+function expressionArguments(args) {
+	return args.children().filter((child) => ![
+		"(",
+		")",
+		","
+	].includes(child.kind()));
+}
+function thirdArgument(member) {
+	const call = member.parent();
+	if (call?.kind() !== "call_expression") return null;
+	const args = call.field("arguments");
+	if (!args) return null;
+	return expressionArguments(args)[2] ?? null;
+}
+/**
+* A `triggerWorkflow(name, args, options)` call whose third argument is not a
+* literal object (e.g. a variable), or is an object literal that spreads one
+* (`{ ...rest }`), cannot be safely renamed: we cannot tell whether it carries
+* an `invoker` key that also needs renaming to `authInvoker`, and renaming
+* just the method name would erase the `triggerWorkflow` token that flags the
+* call for manual review, while the option silently stops working at
+* runtime. Such calls are left entirely unrenamed.
+* @param member - The `.triggerWorkflow` member-expression node being considered
+* @returns Whether the call must be skipped
+*/
+function hasUnsafeThirdArgument(member) {
+	const optionsArg = thirdArgument(member);
+	if (optionsArg === null) return false;
+	if (optionsArg.kind() !== "object") return true;
+	return optionsArg.children().some((child) => child.kind() === "spread_element");
+}
+/**
+* `triggerWorkflow`'s removed SDK wrapper converted an `invoker` option to
+* the platform's `authInvoker` shape before calling through; `startWorkflow`
+* expects `authInvoker` directly. Build an edit renaming a literal `invoker`
+* key (or shorthand) in the third argument of a `triggerWorkflow(...)` call
+* being renamed to `startWorkflow`, so the option keeps working.
+* @param member - The `.triggerWorkflow` member-expression node being renamed
+* @returns An edit renaming the `invoker` key, or null when not applicable
+*/
+function findInvokerOptionEdit(member) {
+	const optionsArg = thirdArgument(member);
+	if (!optionsArg || optionsArg.kind() !== "object") return null;
+	for (const child of optionsArg.children()) if (child.kind() === "pair") {
+		const key = child.field("key");
+		if (key?.kind() === "property_identifier" && key.text() === "invoker") return key.replace("authInvoker");
+	} else if (child.kind() === "shorthand_property_identifier" && child.text() === "invoker") return child.replace("authInvoker: invoker");
+	return null;
+}
+/**
+* Rewrite `.triggerWorkflow(`, `.triggerJobFunction(`, and `.resumeWorkflow(`
+* member accesses to their canonical `startWorkflow`/`execJobFunction`/
+* `resumeWorkflowExecution` names,
+* either on the ambient `tailor.workflow` global or on a `workflow` value
+* imported from `@tailor-platform/sdk/runtime(/workflow)`.
+* @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 imports = findImportStatements(root);
+	const workflowLocals = collectWorkflowLocals(root, imports);
+	const tailorIsAmbient = tailorIsAmbientGlobal(root, imports);
+	const edits = [];
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const property = member.field("property");
+		if (!property || property.kind() !== "property_identifier") continue;
+		const newName = RENAMES[property.text()];
+		if (!newName) continue;
+		const object = member.field("object");
+		if (!object) continue;
+		const isWorkflowImportReceiver = object.kind() === "identifier" && workflowLocals.has(object.text());
+		const isAmbientReceiver = tailorIsAmbient && isAmbientTailorWorkflow(object);
+		if (!isWorkflowImportReceiver && !isAmbientReceiver) continue;
+		if (newName === "startWorkflow") {
+			if (hasUnsafeThirdArgument(member)) continue;
+			edits.push(property.replace(newName));
+			const invokerEdit = findInvokerOptionEdit(member);
+			if (invokerEdit) edits.push(invokerEdit);
+		} else edits.push(property.replace(newName));
+	}
+	if (edits.length === 0) return null;
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+//#endregion
+export { transform as default };