@inkeep/agents-cli 0.51.0 → 0.53.0

package/dist/commands/pull-v4/module-merge.js

@@ -0,0 +1,405 @@
+import { createInMemoryProject } from "./utils.js";
+import { Node, SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/module-merge.ts
+function mergeGeneratedModule(existingContent, generatedContent) {
+	const project = createInMemoryProject();
+	const existingSourceFile = project.createSourceFile("existing.ts", existingContent, { overwrite: true });
+	const generatedSourceFile = project.createSourceFile("generated.ts", generatedContent, { overwrite: true });
+	mergeImports(existingSourceFile, generatedSourceFile);
+	for (const statement of generatedSourceFile.getStatements()) {
+		if (Node.isImportDeclaration(statement)) continue;
+		upsertStatement(existingSourceFile, statement);
+	}
+	return dedupeConsecutiveIdenticalSingleLineComments(existingSourceFile.getFullText().trimEnd());
+}
+function mergeImports(existingFile, generatedFile) {
+	for (const generatedImport of generatedFile.getImportDeclarations()) {
+		const moduleSpecifier = generatedImport.getModuleSpecifierValue();
+		const matchingImports = existingFile.getImportDeclarations().filter((existingImport) => existingImport.getModuleSpecifierValue() === moduleSpecifier);
+		if (!matchingImports.length) {
+			if (areGeneratedImportBindingsAlreadyPresent(existingFile, generatedImport)) continue;
+			if (hasGeneratedImportBindingConflicts(existingFile, generatedImport)) continue;
+			existingFile.addImportDeclaration(generatedImport.getStructure());
+			continue;
+		}
+		const targetImport = findBestImportTarget(matchingImports, generatedImport);
+		if (!targetImport) {
+			if (!hasImportWithText(matchingImports, generatedImport.getText())) existingFile.addImportDeclaration(generatedImport.getStructure());
+			continue;
+		}
+		if (!generatedImport.isTypeOnly() && targetImport.isTypeOnly()) targetImport.setIsTypeOnly(false);
+		const generatedDefaultImport = generatedImport.getDefaultImport();
+		if (generatedDefaultImport && !targetImport.getDefaultImport()) {
+			const defaultImportName = generatedDefaultImport.getText();
+			if (!hasTopLevelDeclarationWithName(existingFile, defaultImportName)) targetImport.setDefaultImport(defaultImportName);
+		}
+		const generatedNamespaceImport = generatedImport.getNamespaceImport();
+		if (generatedNamespaceImport && !targetImport.getNamespaceImport()) {
+			const namespaceImportName = generatedNamespaceImport.getText();
+			if (!hasTopLevelDeclarationWithName(existingFile, namespaceImportName)) targetImport.setNamespaceImport(namespaceImportName);
+		}
+		for (const generatedNamedImport of generatedImport.getNamedImports()) {
+			const generatedName = generatedNamedImport.getName();
+			const generatedAlias = generatedNamedImport.getAliasNode()?.getText();
+			const generatedIsTypeOnly = generatedNamedImport.isTypeOnly();
+			const generatedBindingName = generatedAlias ?? generatedName;
+			if (!targetImport.getNamedImports().some((existingNamedImport) => {
+				return existingNamedImport.getName() === generatedName && existingNamedImport.getAliasNode()?.getText() === generatedAlias && existingNamedImport.isTypeOnly() === generatedIsTypeOnly;
+			})) {
+				if (hasTopLevelDeclarationWithName(existingFile, generatedBindingName)) continue;
+				targetImport.addNamedImport({
+					name: generatedName,
+					alias: generatedAlias,
+					isTypeOnly: generatedIsTypeOnly
+				});
+			}
+		}
+	}
+}
+function findBestImportTarget(matchingImports, generatedImport) {
+	if (generatedImport.getNamespaceImport()) {
+		const namespaceText = generatedImport.getNamespaceImport()?.getText();
+		return matchingImports.find((importDeclaration) => importDeclaration.getNamespaceImport()?.getText() === namespaceText);
+	}
+	const nonNamespaceImport = matchingImports.find((importDeclaration) => !importDeclaration.getNamespaceImport());
+	if (nonNamespaceImport) return nonNamespaceImport;
+}
+function hasImportWithText(imports, text) {
+	return imports.some((importDeclaration) => importDeclaration.getText() === text);
+}
+function areGeneratedImportBindingsAlreadyPresent(existingFile, generatedImport) {
+	const generatedBindings = getImportBindingNames(generatedImport);
+	if (!generatedBindings.length) return false;
+	const existingImports = existingFile.getImportDeclarations();
+	return generatedBindings.every((binding) => existingImports.some((existingImport) => importHasBinding(existingImport, binding)));
+}
+function hasGeneratedImportBindingConflicts(existingFile, generatedImport) {
+	const generatedBindings = getImportBindingNames(generatedImport);
+	if (!generatedBindings.length) return false;
+	return generatedBindings.some((binding) => hasTopLevelDeclarationWithName(existingFile, binding));
+}
+function getImportBindingNames(importDeclaration) {
+	const bindings = [];
+	const defaultImport = importDeclaration.getDefaultImport();
+	if (defaultImport) bindings.push(defaultImport.getText());
+	const namespaceImport = importDeclaration.getNamespaceImport();
+	if (namespaceImport) bindings.push(namespaceImport.getText());
+	for (const namedImport of importDeclaration.getNamedImports()) bindings.push(namedImport.getAliasNode()?.getText() ?? namedImport.getName());
+	return bindings;
+}
+function importHasBinding(importDeclaration, bindingName) {
+	if (importDeclaration.getDefaultImport()?.getText() === bindingName) return true;
+	if (importDeclaration.getNamespaceImport()?.getText() === bindingName) return true;
+	return importDeclaration.getNamedImports().some((namedImport) => {
+		return (namedImport.getAliasNode()?.getText() ?? namedImport.getName()) === bindingName;
+	});
+}
+function hasTopLevelDeclarationWithName(existingFile, declarationName) {
+	if (existingFile.getVariableDeclaration(declarationName)) return true;
+	if (existingFile.getFunction(declarationName)) return true;
+	if (existingFile.getClass(declarationName)) return true;
+	if (existingFile.getInterface(declarationName)) return true;
+	if (existingFile.getTypeAlias(declarationName)) return true;
+	if (existingFile.getEnum(declarationName)) return true;
+	if (existingFile.getModule(declarationName)) return true;
+	return false;
+}
+function upsertStatement(existingFile, generatedStatement) {
+	if (Node.isVariableStatement(generatedStatement)) {
+		upsertVariableStatement(existingFile, generatedStatement);
+		return;
+	}
+	if (Node.isFunctionDeclaration(generatedStatement)) {
+		upsertNamedStatement(existingFile, generatedStatement, (sourceFile, name) => sourceFile.getFunction(name));
+		return;
+	}
+	if (Node.isClassDeclaration(generatedStatement)) {
+		upsertNamedStatement(existingFile, generatedStatement, (sourceFile, name) => sourceFile.getClass(name));
+		return;
+	}
+	if (Node.isInterfaceDeclaration(generatedStatement)) {
+		upsertNamedStatement(existingFile, generatedStatement, (sourceFile, name) => sourceFile.getInterface(name));
+		return;
+	}
+	if (Node.isTypeAliasDeclaration(generatedStatement)) {
+		upsertNamedStatement(existingFile, generatedStatement, (sourceFile, name) => sourceFile.getTypeAlias(name));
+		return;
+	}
+	if (Node.isEnumDeclaration(generatedStatement)) {
+		upsertNamedStatement(existingFile, generatedStatement, (sourceFile, name) => sourceFile.getEnum(name));
+		return;
+	}
+	appendUniqueStatement(existingFile, generatedStatement);
+}
+function upsertVariableStatement(existingFile, generatedStatement) {
+	if (!Node.isVariableStatement(generatedStatement)) return;
+	const generatedDeclarations = generatedStatement.getDeclarations();
+	if (!generatedDeclarations.length) {
+		appendUniqueStatement(existingFile, generatedStatement);
+		return;
+	}
+	const existingStatements = /* @__PURE__ */ new Set();
+	for (const generatedDeclaration of generatedDeclarations) {
+		let existingDeclaration = existingFile.getVariableDeclaration(generatedDeclaration.getName());
+		if (!existingDeclaration) {
+			existingDeclaration = findExistingDeclarationByEntitySignature(existingFile, generatedDeclaration);
+			if (existingDeclaration) generatedDeclaration.rename(existingDeclaration.getName());
+		}
+		if (!existingDeclaration) continue;
+		const existingStatement = existingDeclaration.getFirstAncestorByKind(SyntaxKind.VariableStatement);
+		if (existingStatement) existingStatements.add(existingStatement);
+	}
+	if (!existingStatements.size) {
+		appendUniqueStatement(existingFile, generatedStatement);
+		return;
+	}
+	const [firstExistingStatement, ...remainingStatements] = [...existingStatements];
+	if (firstExistingStatement) firstExistingStatement.replaceWithText(buildReplacementStatementText(firstExistingStatement, generatedStatement));
+	for (const statement of remainingStatements) statement.remove();
+}
+function findExistingDeclarationByEntitySignature(existingFile, generatedDeclaration) {
+	const generatedSignature = getVariableDeclarationEntitySignature(generatedDeclaration);
+	if (!generatedSignature) return;
+	const matchingDeclarations = existingFile.getVariableDeclarations().filter((declaration) => getVariableDeclarationEntitySignature(declaration) === generatedSignature);
+	if (!matchingDeclarations.length) return;
+	return matchingDeclarations.find((declaration) => declaration.getFirstAncestorByKind(SyntaxKind.VariableStatement)?.hasExportKeyword()) ?? matchingDeclarations[0];
+}
+function getVariableDeclarationEntitySignature(declaration) {
+	const initializer = declaration.getInitializer();
+	if (!initializer || !Node.isCallExpression(initializer)) return;
+	const expression = initializer.getExpression();
+	if (!Node.isIdentifier(expression)) return;
+	const args = initializer.getArguments();
+	if (!args.length || !Node.isObjectLiteralExpression(args[0])) return;
+	const factoryName = expression.getText();
+	const entityId = readEntityId(args[0], factoryName);
+	if (!entityId) return;
+	return `${factoryName}:${entityId}`;
+}
+function readEntityId(configObject, factoryName) {
+	const idProperty = configObject.getProperty("id");
+	if (idProperty && Node.isPropertyAssignment(idProperty)) {
+		const idInitializer = idProperty.getInitializer();
+		if (idInitializer && Node.isStringLiteral(idInitializer)) return idInitializer.getLiteralValue();
+	}
+	if (factoryName === "statusComponent") {
+		const typeProperty = configObject.getProperty("type");
+		if (typeProperty && Node.isPropertyAssignment(typeProperty)) {
+			const typeInitializer = typeProperty.getInitializer();
+			if (typeInitializer && Node.isStringLiteral(typeInitializer)) return typeInitializer.getLiteralValue();
+		}
+	}
+	if (factoryName === "functionTool") {
+		const nameProperty = configObject.getProperty("name");
+		if (nameProperty && Node.isPropertyAssignment(nameProperty)) {
+			const nameInitializer = nameProperty.getInitializer();
+			if (nameInitializer && Node.isStringLiteral(nameInitializer)) return nameInitializer.getLiteralValue();
+		}
+	}
+}
+function upsertNamedStatement(existingFile, generatedStatement, finder) {
+	const statementName = Node.isFunctionDeclaration(generatedStatement) || Node.isClassDeclaration(generatedStatement) || Node.isInterfaceDeclaration(generatedStatement) || Node.isTypeAliasDeclaration(generatedStatement) || Node.isEnumDeclaration(generatedStatement) ? generatedStatement.getName() : void 0;
+	if (!statementName) {
+		appendUniqueStatement(existingFile, generatedStatement);
+		return;
+	}
+	const existingStatement = finder(existingFile, statementName);
+	if (!existingStatement) {
+		appendUniqueStatement(existingFile, generatedStatement);
+		return;
+	}
+	existingStatement.replaceWithText(buildReplacementStatementText(existingStatement, generatedStatement));
+}
+function appendUniqueStatement(existingFile, generatedStatement) {
+	const statementText = generatedStatement.getText();
+	if (existingFile.getStatements().some((statement) => statement.getText() === statementText)) return;
+	existingFile.addStatements([statementText]);
+}
+function buildReplacementStatementText(existingStatement, generatedStatement) {
+	return withPreservedLeadingComments(existingStatement, alignStatementOrdering(existingStatement, generatedStatement));
+}
+function alignStatementOrdering(existingStatement, generatedStatement) {
+	if (Node.isVariableStatement(existingStatement) && Node.isVariableStatement(generatedStatement)) return alignVariableStatementOrdering(existingStatement, generatedStatement);
+	return generatedStatement.getText();
+}
+function alignVariableStatementOrdering(existingStatement, generatedStatement) {
+	generatedStatement.setIsExported(existingStatement.isExported());
+	const generatedText = generatedStatement.getText();
+	const generatedStatementStart = generatedStatement.getStart();
+	const existingDeclarationsByName = new Map(existingStatement.getDeclarations().map((declaration) => [declaration.getName(), declaration]));
+	const replacements = [];
+	for (const generatedDeclaration of generatedStatement.getDeclarations()) {
+		const existingDeclaration = existingDeclarationsByName.get(generatedDeclaration.getName());
+		if (!existingDeclaration) continue;
+		const generatedInitializer = generatedDeclaration.getInitializer();
+		const existingInitializer = existingDeclaration.getInitializer();
+		if (!generatedInitializer || !existingInitializer) continue;
+		const alignedInitializerText = alignExpressionText(existingInitializer, generatedInitializer);
+		if (alignedInitializerText === generatedInitializer.getText()) continue;
+		replacements.push({
+			start: generatedInitializer.getStart() - generatedStatementStart,
+			end: generatedInitializer.getEnd() - generatedStatementStart,
+			text: alignedInitializerText
+		});
+	}
+	return applyTextReplacements(generatedText, replacements);
+}
+function alignExpressionText(existingExpression, generatedExpression) {
+	if (!existingExpression) return generatedExpression.getText();
+	if (Node.isObjectLiteralExpression(existingExpression) && Node.isObjectLiteralExpression(generatedExpression)) return alignObjectLiteralText(existingExpression, generatedExpression);
+	if (Node.isArrayLiteralExpression(existingExpression) && Node.isArrayLiteralExpression(generatedExpression)) return alignArrayLiteralText(existingExpression, generatedExpression);
+	if (Node.isArrowFunction(existingExpression) && Node.isArrowFunction(generatedExpression)) return alignArrowFunctionText(existingExpression, generatedExpression);
+	if (Node.isCallExpression(existingExpression) && Node.isCallExpression(generatedExpression)) return alignCallExpressionText(existingExpression, generatedExpression);
+	if (Node.isParenthesizedExpression(existingExpression) && Node.isParenthesizedExpression(generatedExpression)) return `(${alignExpressionText(existingExpression.getExpression(), generatedExpression.getExpression())})`;
+	return generatedExpression.getText();
+}
+function alignCallExpressionText(existingCall, generatedCall) {
+	if (!Node.isCallExpression(existingCall) || !Node.isCallExpression(generatedCall)) return generatedCall.getText();
+	const generatedText = generatedCall.getText();
+	const generatedCallStart = generatedCall.getStart();
+	const existingArguments = existingCall.getArguments();
+	const generatedArguments = generatedCall.getArguments();
+	const replacements = [];
+	for (const [index, generatedArgument] of generatedArguments.entries()) {
+		const existingArgument = existingArguments[index];
+		if (!existingArgument) continue;
+		const alignedArgumentText = alignExpressionText(existingArgument, generatedArgument);
+		if (alignedArgumentText === generatedArgument.getText()) continue;
+		replacements.push({
+			start: generatedArgument.getStart() - generatedCallStart,
+			end: generatedArgument.getEnd() - generatedCallStart,
+			text: alignedArgumentText
+		});
+	}
+	return applyTextReplacements(generatedText, replacements);
+}
+function alignArrowFunctionText(existingArrow, generatedArrow) {
+	if (!Node.isArrowFunction(existingArrow) || !Node.isArrowFunction(generatedArrow)) return generatedArrow.getText();
+	const existingBody = existingArrow.getBody();
+	const generatedBody = generatedArrow.getBody();
+	if (!Node.isExpression(existingBody) || !Node.isExpression(generatedBody)) return generatedArrow.getText();
+	const alignedBodyText = alignExpressionText(existingBody, generatedBody);
+	if (alignedBodyText === generatedBody.getText()) return generatedArrow.getText();
+	return applyTextReplacements(generatedArrow.getText(), [{
+		start: generatedBody.getStart() - generatedArrow.getStart(),
+		end: generatedBody.getEnd() - generatedArrow.getStart(),
+		text: alignedBodyText
+	}]);
+}
+function alignObjectLiteralText(existingObject, generatedObject) {
+	const propertyTexts = orderObjectProperties(existingObject.getProperties(), generatedObject.getProperties()).map(({ existingProperty, generatedProperty }) => {
+		if (!existingProperty) return generatedProperty.getText();
+		return withPreservedLeadingComments(existingProperty, alignObjectPropertyText(existingProperty, generatedProperty));
+	});
+	return formatCollectionLiteralText(generatedObject.getText(), propertyTexts, "{", "}");
+}
+function alignObjectPropertyText(existingProperty, generatedProperty) {
+	const text = generatedProperty.getText();
+	if (!Node.isPropertyAssignment(generatedProperty)) return text;
+	const generatedInitializer = generatedProperty.getInitializer();
+	if (!generatedInitializer) return text;
+	const alignedInitializerText = alignExpressionText(Node.isPropertyAssignment(existingProperty) ? existingProperty.getInitializer() : void 0, generatedInitializer);
+	return `${generatedProperty.getNameNode().getText()}: ${alignedInitializerText}`;
+}
+function alignArrayLiteralText(existingArray, generatedArray) {
+	if (!Node.isArrayLiteralExpression(existingArray) || !Node.isArrayLiteralExpression(generatedArray)) return generatedArray.getText();
+	const elementTexts = orderArrayElements(existingArray.getElements(), generatedArray.getElements()).map(({ existingElement, generatedElement }) => alignExpressionText(existingElement, generatedElement));
+	return formatCollectionLiteralText(generatedArray.getText(), elementTexts, "[", "]");
+}
+function orderObjectProperties(existingProperties, generatedProperties) {
+	return orderNodesBySignature(existingProperties, generatedProperties, getObjectPropertyKey, getObjectPropertyKey).map(({ existingNode, generatedNode }) => ({
+		existingProperty: existingNode,
+		generatedProperty: generatedNode
+	}));
+}
+function orderArrayElements(existingElements, generatedElements) {
+	return orderNodesBySignature(existingElements, generatedElements, getArrayElementSignature, getArrayElementSignature).map(({ existingNode, generatedNode }) => ({
+		existingElement: existingNode,
+		generatedElement: generatedNode
+	}));
+}
+function orderNodesBySignature(existingNodes, generatedNodes, getExistingSignature, getGeneratedSignature) {
+	const generatedEntries = generatedNodes.map((generatedNode) => ({
+		generatedNode,
+		signature: getGeneratedSignature(generatedNode)
+	}));
+	const usedGeneratedIndexes = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const existingNode of existingNodes) {
+		const existingSignature = getExistingSignature(existingNode);
+		if (!existingSignature) continue;
+		const generatedIndex = generatedEntries.findIndex((entry, index) => !usedGeneratedIndexes.has(index) && entry.signature === existingSignature);
+		if (generatedIndex === -1) continue;
+		const generatedEntry = generatedEntries[generatedIndex];
+		if (!generatedEntry) continue;
+		usedGeneratedIndexes.add(generatedIndex);
+		ordered.push({
+			existingNode,
+			generatedNode: generatedEntry.generatedNode
+		});
+	}
+	for (const [index, generatedEntry] of generatedEntries.entries()) {
+		if (usedGeneratedIndexes.has(index)) continue;
+		ordered.push({ generatedNode: generatedEntry.generatedNode });
+	}
+	return ordered;
+}
+function getObjectPropertyKey(property) {
+	if (Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property) || Node.isMethodDeclaration(property) || Node.isGetAccessorDeclaration(property) || Node.isSetAccessorDeclaration(property)) return property.getName();
+	if (Node.isSpreadAssignment(property)) return `...${property.getExpression().getText()}`;
+}
+function getArrayElementSignature(node) {
+	if (Node.isIdentifier(node)) return `id:${node.getText()}`;
+	if (Node.isStringLiteral(node)) return `str:${node.getLiteralValue()}`;
+	if (Node.isObjectLiteralExpression(node)) {
+		const objectId = readStringLiteralObjectProperty(node, "id") || readStringLiteralObjectProperty(node, "type") || readStringLiteralObjectProperty(node, "name");
+		if (objectId) return `obj:${objectId}`;
+	}
+	if (Node.isCallExpression(node)) {
+		const expression = node.getExpression();
+		if (Node.isPropertyAccessExpression(expression) && expression.getName() === "with") return `with:${expression.getExpression().getText()}`;
+	}
+	return node.getText();
+}
+function readStringLiteralObjectProperty(objectLiteral, propertyName) {
+	const property = objectLiteral.getProperty(propertyName);
+	if (!property || !Node.isPropertyAssignment(property)) return;
+	const initializer = property.getInitializer();
+	if (!initializer || !Node.isStringLiteral(initializer)) return;
+	return initializer.getLiteralValue();
+}
+function formatCollectionLiteralText(originalText, itemTexts, openToken, closeToken) {
+	if (originalText.includes("\n")) return `${openToken}\n${itemTexts.map((line) => {
+		return line.replaceAll(/^\s+\*/gm, " *");
+	}).join(",\n")}${closeToken}`;
+	const openingWithSpacing = originalText.startsWith(`${openToken} `) ? `${openToken} ` : openToken;
+	const closingWithSpacing = originalText.endsWith(` ${closeToken}`) ? ` ${closeToken}` : closeToken;
+	return `${openingWithSpacing}${itemTexts.join(", ")}${closingWithSpacing}`;
+}
+function applyTextReplacements(sourceText, replacements) {
+	if (!replacements.length) return sourceText;
+	let nextText = sourceText;
+	const replacementsInDescendingOrder = [...replacements].sort((a, b) => b.start - a.start);
+	for (const replacement of replacementsInDescendingOrder) nextText = nextText.slice(0, replacement.start) + replacement.text + nextText.slice(replacement.end);
+	return nextText;
+}
+function withPreservedLeadingComments(existingStatement, replacementText) {
+	const leadingComments = existingStatement.getLeadingCommentRanges().map((comment) => comment.getText()).join("\n");
+	if (!leadingComments) return replacementText;
+	return `${leadingComments}\n${replacementText}`;
+}
+function dedupeConsecutiveIdenticalSingleLineComments(content) {
+	const lines = content.split("\n");
+	const deduped = [];
+	for (const line of lines) {
+		const trimmedLine = line.trim();
+		const previousTrimmedLine = deduped.at(-1)?.trim();
+		if (trimmedLine.startsWith("//") && previousTrimmedLine?.startsWith("//") && trimmedLine === previousTrimmedLine) continue;
+		deduped.push(line);
+	}
+	return deduped.join("\n");
+}
+
+//#endregion
+export { mergeGeneratedModule };

package/dist/commands/pull-v4/utils.js

@@ -0,0 +1,235 @@
+import path from "node:path";
+import { IndentationText, NewLineKind, Project, QuoteKind, SyntaxKind, VariableDeclarationKind } from "ts-morph";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v4/utils.ts
+function createInMemoryProject() {
+	return new Project({
+		useInMemoryFileSystem: true,
+		skipLoadingLibFiles: true,
+		manipulationSettings: {
+			indentationText: IndentationText.TwoSpaces,
+			quoteKind: QuoteKind.Single,
+			newLineKind: NewLineKind.LineFeed,
+			useTrailingCommas: true
+		}
+	});
+}
+/**
+* Create variable in following pattern
+*
+* (export)? const VARIABLE_NAME = (new)?IMPORT_NAME({})
+*/
+function addFactoryConfigVariable({ sourceFile, importName, variableName, isExported, syntaxKind = SyntaxKind.CallExpression }) {
+	const initializer = `${syntaxKind === SyntaxKind.NewExpression ? "new " : ""}${importName}({})`;
+	const [declaration] = sourceFile.addVariableStatement({
+		declarationKind: VariableDeclarationKind.Const,
+		isExported,
+		declarations: [{
+			name: variableName,
+			initializer
+		}]
+	}).getDeclarations();
+	const [configArg] = declaration.getInitializerIfKindOrThrow(syntaxKind).getArguments();
+	return { configObject: configArg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression) };
+}
+function createFactoryDefinition({ importName, variableName: name, fileName = "definition.ts", moduleSpecifier = "@inkeep/agents-sdk", syntaxKind }) {
+	const sourceFile = createInMemoryProject().createSourceFile(fileName, "", { overwrite: true });
+	sourceFile.addImportDeclaration({
+		namedImports: [importName],
+		moduleSpecifier
+	});
+	const { configObject } = addFactoryConfigVariable({
+		sourceFile,
+		importName,
+		variableName: name,
+		isExported: true,
+		syntaxKind
+	});
+	return {
+		sourceFile,
+		configObject
+	};
+}
+function toCamelCase(input) {
+	const result = input.replace(/[^a-zA-Z0-9](.)/g, (_, char) => char.toUpperCase()).replace(/^[0-9]/, "_$&");
+	return result.charAt(0).toLowerCase() + result.slice(1);
+}
+function createUniqueReferenceName(baseName, reservedNames, conflictSuffix) {
+	if (!reservedNames.has(baseName)) {
+		reservedNames.add(baseName);
+		return baseName;
+	}
+	const baseCandidate = `${baseName}${conflictSuffix}`;
+	if (!reservedNames.has(baseCandidate)) {
+		reservedNames.add(baseCandidate);
+		return baseCandidate;
+	}
+	let index = 2;
+	while (reservedNames.has(`${baseCandidate}${index}`)) index += 1;
+	const uniqueName = `${baseCandidate}${index}`;
+	reservedNames.add(uniqueName);
+	return uniqueName;
+}
+function resolveReferenceName(referenceId, referenceOverrides) {
+	for (const overrideMap of referenceOverrides) {
+		const overrideName = overrideMap?.[referenceId];
+		if (overrideName) return overrideName;
+	}
+	return toCamelCase(referenceId);
+}
+function convertJsonSchemaToZodSafe(schema, options) {
+	if (!isPlainObject(schema)) {
+		console.warn("Schema conversion skipped: non-object schema provided, using z.any()");
+		return "z.any()";
+	}
+	try {
+		return jsonSchemaToZod(schema, options?.conversionOptions);
+	} catch (error) {
+		console.warn(`Schema conversion failed: ${error instanceof Error ? error.message : String(error)}. Falling back to z.any()`);
+		return "z.any()";
+	}
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const QUOTE = Object.freeze({
+	single: "'",
+	double: "\"",
+	template: "`"
+});
+const TEMPLATE_VARIABLE_REGEX = /\{\{(?!\{)(?<variableName>[^{}]+)}}/g;
+function formatStringLiteral(value) {
+	const hasSingleQuote = value.includes(QUOTE.single);
+	const hasDoubleQuote = value.includes(QUOTE.double);
+	return escapeStringLiteral(value, value.includes("\n") || value.includes("${") || hasSingleQuote && hasDoubleQuote ? QUOTE.template : hasSingleQuote ? QUOTE.double : QUOTE.single);
+}
+function collectTemplateVariableNames(value) {
+	const variables = [];
+	for (const match of value.matchAll(TEMPLATE_VARIABLE_REGEX)) {
+		const variableName = match.groups?.variableName?.trim();
+		if (variableName) variables.push(variableName);
+	}
+	return variables;
+}
+function formatTemplate(value, references) {
+	if (!value.length) return value;
+	let didReplace = false;
+	const rewrittenValue = value.replace(TEMPLATE_VARIABLE_REGEX, (match, ...args) => {
+		const maybeGroups = args.at(-1);
+		const variableName = isPlainObject(maybeGroups) && typeof maybeGroups.variableName === "string" ? maybeGroups.variableName.trim() : void 0;
+		if (!variableName) return match;
+		if (variableName.startsWith("headers.")) {
+			const headerPath = variableName.slice(8);
+			if (!headerPath || !references.headersReference) return match;
+			didReplace = true;
+			return `\${${references.headersReference}.toTemplate(${JSON.stringify(headerPath)})}`;
+		}
+		if (!references.contextReference) return match;
+		didReplace = true;
+		return `\${${references.contextReference}.toTemplate(${JSON.stringify(variableName)})}`;
+	});
+	return didReplace ? rewrittenValue : value;
+}
+function escapeStringLiteral(value, quote) {
+	return [
+		quote,
+		value.replaceAll("\\", "\\\\").replaceAll(quote, `\\${quote}`),
+		quote
+	].join("");
+}
+function formatPropertyName(key) {
+	if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) return key;
+	return formatStringLiteral(key);
+}
+function formatInlineLiteral(value) {
+	if (typeof value === "string") return formatStringLiteral(value);
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (value === null) return "null";
+	if (Array.isArray(value)) return `[${value.map((item) => formatInlineLiteral(item)).join(", ")}]`;
+	if (isPlainObject(value)) {
+		const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0);
+		if (!entries.length) return "{}";
+		return `{ ${entries.map(([key, entryValue]) => `${formatPropertyName(key)}: ${formatInlineLiteral(entryValue)}`).join(", ")} }`;
+	}
+	return "undefined";
+}
+function addReferenceGetterProperty(configObject, key, refs) {
+	configObject.addPropertyAssignment({
+		name: key,
+		initializer: "() => []"
+	}).getInitializerIfKindOrThrow(SyntaxKind.ArrowFunction).getBody().asKindOrThrow(SyntaxKind.ArrayLiteralExpression).addElements(refs);
+}
+function addObjectEntries(target, value) {
+	for (const [key, entryValue] of Object.entries(value)) {
+		if (entryValue === void 0) continue;
+		if (isPlainObject(entryValue)) {
+			addObjectEntries(target.addPropertyAssignment({
+				name: formatPropertyName(key),
+				initializer: "{}"
+			}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression), entryValue);
+			continue;
+		}
+		target.addPropertyAssignment({
+			name: formatPropertyName(key),
+			initializer: formatInlineLiteral(entryValue)
+		});
+	}
+}
+function addStringProperty(configObject, key, value) {
+	configObject.addPropertyAssignment({
+		name: key,
+		initializer: formatStringLiteral(value)
+	});
+}
+function addValueToObject(obj, key, value) {
+	if (value === void 0) return;
+	if (isPlainObject(value)) {
+		const child = obj.addPropertyAssignment({
+			name: formatPropertyName(key),
+			initializer: "{}"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		for (const [k, v] of Object.entries(value)) addValueToObject(child, k, v);
+		return;
+	}
+	if (Array.isArray(value)) {
+		const arr = obj.addPropertyAssignment({
+			name: formatPropertyName(key),
+			initializer: "[]"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		for (const item of value) addValueToArray(arr, item);
+		return;
+	}
+	obj.addPropertyAssignment({
+		name: formatPropertyName(key),
+		initializer: formatInlineLiteral(value)
+	});
+}
+function addValueToArray(arr, value) {
+	if (isPlainObject(value)) {
+		const child = arr.addElement("{}").asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		for (const [k, v] of Object.entries(value)) addValueToObject(child, k, v);
+		return;
+	}
+	if (Array.isArray(value)) {
+		const child = arr.addElement("[]").asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		for (const item of value) addValueToArray(child, item);
+		return;
+	}
+	arr.addElement(formatInlineLiteral(value));
+}
+async function expectSnapshots(definitionV4) {
+	const { currentTestName, snapshotState } = expect.getState();
+	const snapshotDir = path.basename(snapshotState.testFilePath).replace("-generator.test.ts", "");
+	await expect(definitionV4).toMatchFileSnapshot(`__snapshots__/${snapshotDir}/${currentTestName}-v4.txt`);
+}
+function convertNullToUndefined(v) {
+	return v == null ? void 0 : v;
+}
+function hasReferences(references) {
+	return Array.isArray(references) && references.length > 0;
+}
+
+//#endregion
+export { TEMPLATE_VARIABLE_REGEX, addFactoryConfigVariable, addObjectEntries, addReferenceGetterProperty, addStringProperty, addValueToObject, collectTemplateVariableNames, convertJsonSchemaToZodSafe, convertNullToUndefined, createFactoryDefinition, createInMemoryProject, createUniqueReferenceName, expectSnapshots, formatInlineLiteral, formatPropertyName, formatStringLiteral, formatTemplate, hasReferences, isPlainObject, resolveReferenceName, toCamelCase };

package/dist/commands/push.js

@@ -4,10 +4,10 @@ import { initializeCommand } from "../utils/cli-pipeline.js";
 import { performBackgroundVersionCheck } from "../utils/background-version-check.js";
 import { loadProject } from "../utils/project-loader.js";
 import { loadEnvironmentCredentials } from "../utils/environment-loader.js";
-import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
+import { existsSync, readdirSync, statSync } from "node:fs";
 
 //#region src/commands/push.ts
 async function pushCommand(options) {

package/dist/commands/update.js

@@ -1,4 +1,4 @@
-import { checkForUpdate, getChangelogUrl } from "../utils/version-check.js";
+import { PACKAGE_CHANGELOG, checkForUpdate } from "../utils/version-check.js";
 import { detectPackageManager, executeUpdate } from "../utils/package-manager.js";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
@@ -29,7 +29,7 @@ async function updateCommand(options = {}) {
 		}
 		if (!versionInfo.needsUpdate && options.force) console.log(chalk.yellow("\n⚠️  Forcing reinstall of current version..."));
 		console.log(chalk.cyan("\n📖 Changelog:"));
-		console.log(chalk.gray(`  • ${getChangelogUrl()}`));
+		console.log(chalk.gray(`  • ${PACKAGE_CHANGELOG}`));
 		s.start("Detecting package manager...");
 		const detectedManager = await detectPackageManager();
 		s.stop();