@inkeep/agents-cli 0.51.0 → 0.52.0

package/dist/commands/pull-v4/mcp-tool-generator.js

@@ -0,0 +1,91 @@
+import { addValueToObject, createFactoryDefinition, formatInlineLiteral, formatStringLiteral, toCamelCase } from "./utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/mcp-tool-generator.ts
+const McpToolSchema = z.looseObject({
+	mcpToolId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().nullable().optional(),
+	config: z.looseObject({ mcp: z.looseObject({
+		server: z.looseObject({ url: z.string().optional() }).optional(),
+		transport: z.unknown().optional(),
+		activeTools: z.array(z.unknown()).optional()
+	}).optional() }).optional(),
+	serverUrl: z.string().optional(),
+	transport: z.object({ type: z.string() }).optional(),
+	activeTools: z.array(z.unknown()).optional(),
+	imageUrl: z.string().optional(),
+	headers: z.unknown().optional(),
+	credential: z.unknown().optional(),
+	credentialReferenceId: z.string().optional()
+}).superRefine((value, context) => {
+	if (!resolveServerUrl(value)) context.addIssue({
+		code: "custom",
+		message: "serverUrl is required (from config.mcp.server.url or serverUrl)",
+		path: ["serverUrl"]
+	});
+});
+function generateMcpToolDefinition(data) {
+	const result = McpToolSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for MCP tool:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "mcpTool",
+		variableName: toCamelCase(parsed.mcpToolId)
+	});
+	if (parsed.credentialReferenceId && parsed.credential === void 0) sourceFile.addImportDeclaration({
+		namedImports: ["envSettings"],
+		moduleSpecifier: "../environments"
+	});
+	writeMcpToolConfig(configObject, parsed);
+	return sourceFile;
+}
+function writeMcpToolConfig(configObject, { mcpToolId, description, serverUrl, config, transport, activeTools, credential, credentialReferenceId, ...rest }) {
+	for (const [k, v] of Object.entries({
+		id: mcpToolId,
+		...rest,
+		description: description ?? void 0,
+		serverUrl: resolveServerUrl({
+			config,
+			serverUrl
+		}),
+		transport: resolveTransport({
+			config,
+			transport
+		}),
+		activeTools: resolveActiveTools({
+			config,
+			activeTools
+		})
+	})) addValueToObject(configObject, k, v);
+	if (credential !== void 0 && credential !== null) {
+		if (typeof credential === "string") {
+			configObject.addPropertyAssignment({
+				name: "credential",
+				initializer: credential
+			});
+			return;
+		}
+		configObject.addPropertyAssignment({
+			name: "credential",
+			initializer: formatInlineLiteral(credential)
+		});
+		return;
+	}
+	if (credentialReferenceId) configObject.addPropertyAssignment({
+		name: "credential",
+		initializer: `envSettings.getEnvironmentCredential(${formatStringLiteral(credentialReferenceId)})`
+	});
+}
+function resolveServerUrl(data) {
+	return data.config?.mcp?.server?.url ?? data.serverUrl;
+}
+function resolveTransport(data) {
+	return data.config?.mcp?.transport ?? data.transport;
+}
+function resolveActiveTools(data) {
+	return data.config?.mcp?.activeTools ?? data.activeTools;
+}
+
+//#endregion
+export { generateMcpToolDefinition };

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

@@ -0,0 +1,379 @@
+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;
+			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()) targetImport.setDefaultImport(generatedDefaultImport.getText());
+		const generatedNamespaceImport = generatedImport.getNamespaceImport();
+		if (generatedNamespaceImport && !targetImport.getNamespaceImport()) targetImport.setNamespaceImport(generatedNamespaceImport.getText());
+		for (const generatedNamedImport of generatedImport.getNamedImports()) {
+			const generatedName = generatedNamedImport.getName();
+			const generatedAlias = generatedNamedImport.getAliasNode()?.getText();
+			const generatedIsTypeOnly = generatedNamedImport.isTypeOnly();
+			if (!targetImport.getNamedImports().some((existingNamedImport) => {
+				return existingNamedImport.getName() === generatedName && existingNamedImport.getAliasNode()?.getText() === generatedAlias && existingNamedImport.isTypeOnly() === generatedIsTypeOnly;
+			})) 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 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 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/project-generator.js

@@ -0,0 +1,101 @@
+import { addReferenceGetterProperty, addValueToObject, convertNullToUndefined, createFactoryDefinition, formatStringLiteral, hasReferences, resolveReferenceName, toCamelCase } from "./utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/project-generator.ts
+const ReferenceNameByIdSchema = z.record(z.string(), z.string().nonempty());
+const ReferenceOverridesSchema = z.object({
+	agents: ReferenceNameByIdSchema.optional(),
+	tools: ReferenceNameByIdSchema.optional(),
+	externalAgents: ReferenceNameByIdSchema.optional(),
+	dataComponents: ReferenceNameByIdSchema.optional(),
+	artifactComponents: ReferenceNameByIdSchema.optional(),
+	credentialReferences: ReferenceNameByIdSchema.optional()
+});
+const ProjectSchema = z.looseObject({
+	projectId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().optional(),
+	models: z.looseObject({
+		base: z.looseObject({ model: z.string().nonempty() }),
+		structuredOutput: z.looseObject({}).optional(),
+		summarizer: z.looseObject({}).optional()
+	}),
+	stopWhen: z.preprocess(convertNullToUndefined, z.strictObject({
+		transferCountIs: z.int().optional(),
+		stepCountIs: z.int().optional()
+	}).optional()),
+	skills: z.array(z.string()).optional(),
+	agents: z.array(z.string()).optional(),
+	tools: z.array(z.string()).optional(),
+	externalAgents: z.array(z.string()).optional(),
+	dataComponents: z.array(z.string()).optional(),
+	artifactComponents: z.array(z.string()).optional(),
+	credentialReferences: z.array(z.string()).optional(),
+	referenceOverrides: ReferenceOverridesSchema.optional()
+});
+function generateProjectDefinition(data) {
+	const result = ProjectSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for project:
+${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "project",
+		variableName: toCamelCase(parsed.projectId)
+	});
+	if (hasReferences(parsed.skills)) {
+		sourceFile.getImportDeclarationOrThrow("@inkeep/agents-sdk").addNamedImport("loadSkills");
+		sourceFile.addImportDeclaration({
+			defaultImport: "path",
+			moduleSpecifier: "node:path"
+		});
+	}
+	const { projectId, skills, agents, tools, externalAgents, dataComponents, artifactComponents, credentialReferences, referenceOverrides, ...rest } = parsed;
+	for (const [key, value] of Object.entries({
+		id: projectId,
+		...rest
+	})) addValueToObject(configObject, key, value);
+	if (hasReferences(skills)) configObject.addPropertyAssignment({
+		name: "skills",
+		initializer: `() => loadSkills(path.join(${formatStringLiteral(projectId)}, 'skills'))`
+	});
+	if (hasReferences(agents)) {
+		addReferenceImports(sourceFile, agents, "./agents", referenceOverrides?.agents);
+		addReferenceGetterProperty(configObject, "agents", toReferenceNames(agents, referenceOverrides?.agents));
+	}
+	if (hasReferences(tools)) {
+		addReferenceImports(sourceFile, tools, "./tools", referenceOverrides?.tools);
+		addReferenceGetterProperty(configObject, "tools", toReferenceNames(tools, referenceOverrides?.tools));
+	}
+	if (hasReferences(externalAgents)) {
+		addReferenceImports(sourceFile, externalAgents, "./external-agents", referenceOverrides?.externalAgents);
+		addReferenceGetterProperty(configObject, "externalAgents", toReferenceNames(externalAgents, referenceOverrides?.externalAgents));
+	}
+	if (hasReferences(dataComponents)) {
+		addReferenceImports(sourceFile, dataComponents, "./data-components", referenceOverrides?.dataComponents);
+		addReferenceGetterProperty(configObject, "dataComponents", toReferenceNames(dataComponents, referenceOverrides?.dataComponents));
+	}
+	if (hasReferences(artifactComponents)) {
+		addReferenceImports(sourceFile, artifactComponents, "./artifact-components", referenceOverrides?.artifactComponents);
+		addReferenceGetterProperty(configObject, "artifactComponents", toReferenceNames(artifactComponents, referenceOverrides?.artifactComponents));
+	}
+	if (hasReferences(credentialReferences)) {
+		addReferenceImports(sourceFile, credentialReferences, "./credentials", referenceOverrides?.credentialReferences);
+		addReferenceGetterProperty(configObject, "credentialReferences", toReferenceNames(credentialReferences, referenceOverrides?.credentialReferences));
+	}
+	return sourceFile;
+}
+function addReferenceImports(sourceFile, references, basePath, referenceOverrides) {
+	for (const reference of references) {
+		const referenceName = resolveReferenceName(reference, [referenceOverrides]);
+		sourceFile.addImportDeclaration({
+			namedImports: [referenceName],
+			moduleSpecifier: `${basePath}/${reference}`
+		});
+	}
+}
+function toReferenceNames(references, referenceOverrides) {
+	return references.map((reference) => resolveReferenceName(reference, [referenceOverrides]));
+}
+
+//#endregion
+export { generateProjectDefinition };

package/dist/commands/pull-v4/status-component-generator.js

@@ -0,0 +1,35 @@
+import { addValueToObject, convertJsonSchemaToZodSafe, createFactoryDefinition, toCamelCase } from "./utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/status-component-generator.ts
+const StatusComponentSchema = z.looseObject({
+	statusComponentId: z.string().nonempty(),
+	type: z.string().nonempty(),
+	description: z.string().optional(),
+	detailsSchema: z.unknown().optional(),
+	schema: z.unknown().optional()
+});
+function generateStatusComponentDefinition(data) {
+	const result = StatusComponentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for status component:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const detailsSchema = parsed.detailsSchema !== void 0 ? parsed.detailsSchema : parsed.schema;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "statusComponent",
+		variableName: toCamelCase(parsed.statusComponentId)
+	});
+	if (detailsSchema !== void 0) sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	const { statusComponentId, id, detailsSchema: _, schema: _2, ...rest } = parsed;
+	for (const [k, v] of Object.entries(rest)) addValueToObject(configObject, k, v);
+	if (detailsSchema) configObject.addPropertyAssignment({
+		name: "detailsSchema",
+		initializer: convertJsonSchemaToZodSafe(detailsSchema)
+	});
+	return sourceFile;
+}
+
+//#endregion
+export { generateStatusComponentDefinition };