@workos/oagen 0.29.3 → 0.30.0

package/dist/cli/index.mjs

@@ -3775,6 +3775,7 @@ function extractKotlinClassMembers(classBody, source) {
 	const children = classBody.namedChildren;
 	for (let i = 0; i < children.length; i++) {
 		const child = children[i];
+		const declIndex = i;
 		let memberName = null;
 		if (child.type === "property_declaration") memberName = child.children.find((c) => c.type === "variable_declaration")?.children.find((c) => c.type === "simple_identifier")?.text ?? null;
 		else if (child.type === "function_declaration") memberName = child.children.find((c) => c.type === "simple_identifier")?.text ?? null;
@@ -3789,7 +3790,7 @@ function extractKotlinClassMembers(classBody, source) {
 			} else break;
 		}
 		let startIdx = child.startIndex;
-		for (let k = i - 1; k >= 0; k--) {
+		for (let k = declIndex - 1; k >= 0; k--) {
 			const prev = children[k];
 			if (prev.type === "multiline_comment") {
 				if (source.slice(prev.startIndex, prev.endIndex).startsWith("/**")) startIdx = prev.startIndex;
@@ -3858,6 +3859,13 @@ const kotlinMergeAdapter = {
 	isManagedMember(member) {
 		return KOTLIN_MANAGED_ACCESSOR_DOC.test(member.text);
 	},
+	importedNames(imp) {
+		const path = imp.text.replace(/^import\s+/, "").trim();
+		const alias = path.match(/\s+as\s+([A-Za-z_][A-Za-z0-9_]*)$/);
+		if (alias) return [alias[1]];
+		const last = path.split(".").pop();
+		return last && last !== "*" ? [last] : [];
+	},
 	shouldSkipDeepMerge(_symbolName, existingMemberKeys, newMembers) {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
@@ -4740,6 +4748,116 @@ function declarationLineStart(content, declStartIndex) {
 	return prevNewline === -1 ? 0 : prevNewline + 1;
 }
 /**
+* Widen a member's byte range so deleting it removes whole lines.
+*
+* The raw range starts at the declaration (or its docstring), which sits after
+* the member's indentation — splicing it out verbatim leaves that indentation
+* glued to the following line. Extends backwards over the indentation and
+* forwards over the trailing newline, then absorbs the blank line the removal
+* would otherwise duplicate (or strand in front of the block's closing brace).
+*/
+function expandPruneRange(source, rawStart, rawEnd) {
+	let start = rawStart;
+	while (start > 0 && (source[start - 1] === " " || source[start - 1] === "	")) start--;
+	let end = rawEnd;
+	while (end < source.length && (source[end] === " " || source[end] === "	")) end++;
+	end = skipLineBreak(source, end);
+	if (precededByBlankLine(source, start)) {
+		if (startsWithLineBreak(source, end)) end = skipLineBreak(source, end);
+		else if (/^[ \t]*\}/.test(source.slice(end, end + 40))) start = backOverLineBreak(source, start);
+	}
+	return {
+		start,
+		end
+	};
+}
+function startsWithLineBreak(source, idx) {
+	return source[idx] === "\n" || source[idx] === "\r" && source[idx + 1] === "\n";
+}
+function skipLineBreak(source, idx) {
+	let i = idx;
+	if (source[i] === "\r") i++;
+	return source[i] === "\n" ? i + 1 : i;
+}
+function backOverLineBreak(source, idx) {
+	let i = idx;
+	if (source[i - 1] === "\n") i--;
+	if (source[i - 1] === "\r") i--;
+	return i;
+}
+/** Whether the line ending immediately before `idx` (a line start) is empty. */
+function precededByBlankLine(source, idx) {
+	if (idx === 0 || source[idx - 1] !== "\n") return false;
+	const priorLineEnd = backOverLineBreak(source, idx);
+	return priorLineEnd > 0 && source[priorLineEnd - 1] === "\n";
+}
+function referencesIdentifier(source, name) {
+	return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(source);
+}
+/**
+* Blank out comments and string text, preserving offsets and line structure.
+*
+* An identifier lookup over raw source can't tell a live reference from a name
+* that merely survives in prose. That distinction decides whether an import
+* stays: keeping one whose only remaining mention is a KDoc leaves an import of
+* a class the generator no longer emits, which doesn't compile — the very
+* failure the prune exists to prevent.
+*
+* Interpolated expressions are the exception: `"${Agents.NAME}"` is code that
+* sits inside a string literal, and masking it would drop an import the file
+* genuinely uses. String extents are masked around those holes, not over them.
+*
+* Grammar node names come from the adapter's `urlFingerprintConfig`, which
+* already inventories exactly these three categories per language. Comments are
+* matched structurally instead — every grammar we support names them `*comment`.
+*/
+function maskNonCode(tree, source, config) {
+	const stringNodeTypes = new Set(config?.stringNodeTypes ?? []);
+	const interpolationNodeTypes = new Set(config?.interpolationNodeTypes ?? []);
+	const spans = [];
+	const collectStringSpans = (node) => {
+		const holes = [];
+		const findHoles = (n) => {
+			if (interpolationNodeTypes.has(n.type)) {
+				holes.push([n.startIndex, n.endIndex]);
+				return;
+			}
+			for (const child of n.children) findHoles(child);
+		};
+		findHoles(node);
+		let cursor = node.startIndex;
+		for (const [holeStart, holeEnd] of holes) {
+			if (holeStart > cursor) spans.push([cursor, holeStart]);
+			cursor = holeEnd;
+		}
+		if (cursor < node.endIndex) spans.push([cursor, node.endIndex]);
+	};
+	const walk = (node) => {
+		if (node.type.includes("comment")) {
+			spans.push([node.startIndex, node.endIndex]);
+			return;
+		}
+		if (stringNodeTypes.has(node.type)) {
+			collectStringSpans(node);
+			return;
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(tree.rootNode);
+	if (spans.length === 0) return source;
+	let masked = "";
+	let cursor = 0;
+	for (const [spanStart, spanEnd] of spans) {
+		if (spanStart < cursor) continue;
+		masked += source.slice(cursor, spanStart) + source.slice(spanStart, spanEnd).replace(/[^\r\n]/g, " ");
+		cursor = spanEnd;
+	}
+	return masked + source.slice(cursor);
+}
+function removeLines(source, lines) {
+	return source.split("\n").filter((line) => !lines.has(line.trim())).join("\n");
+}
+/**
 * Resolve a docstring range by searching for the nearest matching text before
 * the declaration start. Falls back to parser-provided offsets when search fails.
 */
@@ -4954,6 +5072,7 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 	let deepAdded = 0;
 	let deepPruned = 0;
 	const insertions = [];
+	const prunedTexts = [];
 	if (adapter.extractMembers) {
 		const parser = await getParser(language);
 		const resultTree = safeParse(parser, result);
@@ -4982,10 +5101,9 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			if (pruneEdits.length > 0) {
 				pruneEdits.sort((a, b) => b.start - a.start);
 				for (const edit of pruneEdits) {
-					let end = edit.end;
-					while (end < result.length && (result[end] === " " || result[end] === "	")) end++;
-					if (result[end] === "\n") end++;
-					result = result.slice(0, edit.start) + result.slice(end);
+					const { start, end } = expandPruneRange(result, edit.start, edit.end);
+					prunedTexts.push(result.slice(start, end));
+					result = result.slice(0, start) + result.slice(end);
 				}
 				deepPruned = pruneEdits.length;
 				const reTree = safeParse(parser, result);
@@ -5050,6 +5168,21 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			result = lines.join("\n");
 		}
 	}
+	if (prunedTexts.length > 0 && adapter.importedNames) {
+		const prunedText = prunedTexts.join("\n");
+		const codeOnly = maskNonCode(safeParse(await getParser(language), result), result, adapter.urlFingerprintConfig);
+		const orphaned = /* @__PURE__ */ new Set();
+		for (const imp of existingStatements.imports) {
+			const names = adapter.importedNames(imp);
+			if (names.length === 0) continue;
+			if (!names.some((n) => referencesIdentifier(prunedText, n))) continue;
+			const line = imp.text.trim();
+			const withoutImport = removeLines(codeOnly, new Set([line]));
+			if (names.some((n) => referencesIdentifier(withoutImport, n))) continue;
+			orphaned.add(line);
+		}
+		if (orphaned.size > 0) result = removeLines(result, orphaned);
+	}
 	let docstringUpdates = 0;
 	{
 		const parser = await getParser(language);
@@ -6227,6 +6360,43 @@ function resolveResponseModelName(op) {
 	if (ref.kind === "nullable" && ref.inner.kind === "model") return ref.inner.name;
 	return null;
 }
+/**
+* Find every pair of distinct paths that resolve to the same SDK method name.
+*
+* Emitters already refuse to generate on a collision, but they only run inside
+* the per-language build matrix — so a spec addition that collides fails every
+* matrix job minutes in, with no cheap way to catch it first. Surfacing the same
+* check from `oagen resolve` turns that into a seconds-long precheck.
+*
+* Returns every collision rather than throwing on the first, so a spec that
+* introduces several is fixed in one pass instead of one CI round-trip each.
+*
+* Callers that generate a subset of services must filter to the operations they
+* will actually emit before calling this: a collision between two out-of-scope
+* paths is not that run's problem.
+*/
+function findResolvedMethodCollisions(resolved) {
+	const seen = /* @__PURE__ */ new Map();
+	const collisions = [];
+	for (const r of resolved) {
+		const key = `${r.mountOn}.${r.methodName}`;
+		const current = {
+			httpMethod: r.operation.httpMethod.toUpperCase(),
+			path: r.operation.path
+		};
+		const existing = seen.get(key);
+		if (existing && (existing.path !== current.path || existing.httpMethod !== current.httpMethod)) {
+			collisions.push({
+				key,
+				first: existing,
+				second: current
+			});
+			continue;
+		}
+		if (!existing) seen.set(key, current);
+	}
+	return collisions;
+}
 //#endregion
 //#region src/engine/scoped-services.ts
 /**
@@ -10777,6 +10947,11 @@ async function resolveCommand(opts) {
 	});
 	if (opts.docUrl) ir = expandDocUrls(ir, opts.docUrl);
 	const resolved = resolveOperations(ir, opts.operationHints, opts.mountRules);
+	const collisions = findResolvedMethodCollisions(resolved);
+	if (collisions.length > 0) {
+		const detail = collisions.map((c) => `  ${c.key}: ${c.first.httpMethod} ${c.first.path} conflicts with ${c.second.httpMethod} ${c.second.path}`).join("\n");
+		throw new CommandError(`Resolved operation name collision${collisions.length > 1 ? "s" : ""}:\n${detail}`, "Give one of each pair an explicit `name` in operationHints. Rename the NEW path — renaming an already-shipped method breaks released SDKs.", 1);
+	}
 	if ((opts.format ?? "table") === "json") {
 		const output = resolved.map(toJsonRow);
 		console.log(JSON.stringify(output, null, 2));
@@ -10861,7 +11036,10 @@ function applyConfig(config) {
 function handleError(err) {
 	const exitCode = err instanceof CommandError ? err.exitCode : 1;
 	const message = err instanceof Error ? err.message : String(err);
-	if (message) console.error(message);
+	if (message) {
+		const label = err instanceof CommandError ? "" : `${err instanceof Error ? err.name : "Error"}: `;
+		console.error(`${label}${message}`);
+	}
 	process.exit(exitCode);
 }
 const configArgIdx = process.argv.indexOf("--config");