@inkeep/agents-cli 0.51.0 → 0.53.0

package/dist/commands/pull-v4/generators/credential-generator.js

@@ -0,0 +1,30 @@
+import { addValueToObject, createFactoryDefinition, toCamelCase } from "../utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/generators/credential-generator.ts
+const CredentialSchema = z.object({
+	credentialId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	type: z.string().nonempty(),
+	credentialStoreId: z.string().nonempty(),
+	description: z.string().optional(),
+	retrievalParams: z.unknown().optional()
+});
+function generateCredentialDefinition(data) {
+	const result = CredentialSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for credential:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "credential",
+		variableName: toCamelCase(parsed.credentialId)
+	});
+	const { credentialId, ...rest } = parsed;
+	for (const [k, v] of Object.entries({
+		id: credentialId,
+		...rest
+	})) addValueToObject(configObject, k, v);
+	return sourceFile;
+}
+
+//#endregion
+export { generateCredentialDefinition };

package/dist/commands/pull-v4/generators/data-component-generator.js

@@ -0,0 +1,50 @@
+import { addStringProperty, addValueToObject, convertJsonSchemaToZodSafe, createFactoryDefinition, toCamelCase } from "../utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/generators/data-component-generator.ts
+const DataComponentSchema = z.object({
+	dataComponentId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().nullable().optional(),
+	props: z.unknown().optional(),
+	schema: z.unknown().optional(),
+	render: z.looseObject({
+		component: z.string().optional(),
+		mockData: z.looseObject({}).optional()
+	}).nullable().optional()
+});
+function generateDataComponentDefinition(data) {
+	const result = DataComponentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for data component:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const props = parsed.props !== void 0 ? parsed.props : parsed.schema;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "dataComponent",
+		variableName: toCamelCase(parsed.dataComponentId)
+	});
+	if (props !== void 0) sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	writeDataComponentConfig(configObject, parsed, props);
+	return sourceFile;
+}
+function writeDataComponentConfig(configObject, data, props) {
+	addStringProperty(configObject, "id", data.dataComponentId);
+	addStringProperty(configObject, "name", data.name);
+	if (typeof data.description === "string") addStringProperty(configObject, "description", data.description);
+	if (props !== void 0) configObject.addPropertyAssignment({
+		name: "props",
+		initializer: convertJsonSchemaToZodSafe(props)
+	});
+	if (data.render) addRenderProperty(configObject, data.render);
+}
+function addRenderProperty(configObject, render) {
+	if (render.component) addValueToObject(configObject, "render", {
+		component: render.component,
+		mockData: render.mockData
+	});
+}
+
+//#endregion
+export { generateDataComponentDefinition };

package/dist/commands/pull-v4/generators/environment-generator.js

@@ -0,0 +1,123 @@
+import { addStringProperty, createFactoryDefinition, formatInlineLiteral, formatPropertyName, isPlainObject } from "../utils.js";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/generators/environment-generator.ts
+const EnvironmentSettingsSchema = z.looseObject({ credentials: z.record(z.string(), z.unknown()).nullable().optional() });
+const EnvironmentIndexSchema = z.array(z.string());
+function generateEnvironmentSettingsImports(environmentData) {
+	const imports = [`import { registerEnvironmentSettings } from '@inkeep/agents-sdk';`];
+	if (needsCredentialStoreType(environmentData)) imports.push(`import { CredentialStoreType } from '@inkeep/agents-core';`);
+	return imports;
+}
+function generateEnvironmentIndexImports(environments) {
+	const result = EnvironmentIndexSchema.safeParse(environments);
+	if (!result.success) throw new Error(`Validation failed for environments index:\n${z.prettifyError(result.error)}`);
+	const imports = [`import { createEnvironmentSettings } from '@inkeep/agents-sdk';`];
+	for (const environmentName of result.data) imports.push(`import { ${environmentName} } from './${environmentName}.env';`);
+	return imports;
+}
+function generateEnvironmentSettingsDefinition(environmentName, environmentData) {
+	const environmentNameResult = z.string().nonempty().safeParse(environmentName);
+	if (!environmentNameResult.success) throw new Error(`Validation failed for environment name:\n${z.prettifyError(environmentNameResult.error)}`);
+	const result = EnvironmentSettingsSchema.safeParse(environmentData);
+	if (!result.success) throw new Error(`Validation failed for environment settings:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "registerEnvironmentSettings",
+		variableName: environmentNameResult.data
+	});
+	const hasCredentialStoreType = needsCredentialStoreType(parsed);
+	if (hasCredentialStoreType) sourceFile.addImportDeclaration({
+		namedImports: ["CredentialStoreType"],
+		moduleSpecifier: "@inkeep/agents-core"
+	});
+	addCredentialsProperty(configObject, parsed.credentials, hasCredentialStoreType);
+	return sourceFile;
+}
+function generateEnvironmentIndexDefinition(environments) {
+	const result = EnvironmentIndexSchema.safeParse(environments);
+	if (!result.success) throw new Error(`Validation failed for environments index:\n${z.prettifyError(result.error)}`);
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "createEnvironmentSettings",
+		variableName: "envSettings"
+	});
+	for (const environmentName of result.data) sourceFile.addImportDeclaration({
+		namedImports: [environmentName],
+		moduleSpecifier: `./${environmentName}.env`
+	});
+	for (const environmentName of result.data) configObject.addShorthandPropertyAssignment({ name: environmentName });
+	return sourceFile;
+}
+function generateEnvironmentSettingsFile(environmentName, environmentData) {
+	return generateEnvironmentSettingsDefinition(environmentName, environmentData);
+}
+function generateEnvironmentIndexFile(environments) {
+	return generateEnvironmentIndexDefinition(environments);
+}
+function needsCredentialStoreType(environmentData) {
+	if (!isPlainObject(environmentData.credentials)) return false;
+	return Object.values(environmentData.credentials).some((credential) => isPlainObject(credential) && typeof credential.type === "string" && [
+		"memory",
+		"env",
+		"keychain"
+	].includes(credential.type));
+}
+function addCredentialsProperty(configObject, credentials, hasCredentialStoreType) {
+	if (!isPlainObject(credentials) || !Object.keys(credentials).length) {
+		configObject.addPropertyAssignment({
+			name: "credentials",
+			initializer: "{}"
+		});
+		return;
+	}
+	const credentialsObject = configObject.addPropertyAssignment({
+		name: "credentials",
+		initializer: "{}"
+	}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+	for (const [credentialKey, credentialValue] of Object.entries(credentials)) {
+		if (!isPlainObject(credentialValue)) continue;
+		writeCredential(credentialsObject.addPropertyAssignment({
+			name: formatPropertyName(credentialKey),
+			initializer: "{}"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression), credentialValue, hasCredentialStoreType);
+	}
+}
+function writeCredential(credentialObject, credentialData, hasCredentialStoreType) {
+	if (credentialData.id !== void 0) addStringProperty(credentialObject, "id", credentialData.id);
+	if (credentialData.name !== void 0 && credentialData.name !== null) addStringProperty(credentialObject, "name", credentialData.name);
+	if (credentialData.type !== void 0) if (hasCredentialStoreType && typeof credentialData.type === "string" && [
+		"memory",
+		"env",
+		"keychain"
+	].includes(credentialData.type)) credentialObject.addPropertyAssignment({
+		name: "type",
+		initializer: `CredentialStoreType.${credentialData.type}`
+	});
+	else credentialObject.addPropertyAssignment({
+		name: "type",
+		initializer: formatInlineLiteral(credentialData.type)
+	});
+	if (credentialData.credentialStoreId !== void 0) addStringProperty(credentialObject, "credentialStoreId", credentialData.credentialStoreId);
+	if (credentialData.description !== void 0 && credentialData.description !== null) addStringProperty(credentialObject, "description", credentialData.description);
+	addRetrievalParams(credentialObject, credentialData.retrievalParams);
+}
+function addRetrievalParams(credentialObject, retrievalParams) {
+	if (!isPlainObject(retrievalParams)) return;
+	const retrievalParamsProperty = credentialObject.addPropertyAssignment({
+		name: "retrievalParams",
+		initializer: "{}"
+	});
+	const retrievalParamsObject = retrievalParamsProperty.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+	for (const [key, value] of Object.entries(retrievalParams)) {
+		if (value === void 0 || value === null) continue;
+		retrievalParamsObject.addPropertyAssignment({
+			name: formatPropertyName(key),
+			initializer: formatInlineLiteral(value)
+		});
+	}
+	if (!retrievalParamsObject.getProperties().length) retrievalParamsProperty.remove();
+}
+
+//#endregion
+export { generateEnvironmentIndexDefinition, generateEnvironmentIndexFile, generateEnvironmentIndexImports, generateEnvironmentSettingsDefinition, generateEnvironmentSettingsFile, generateEnvironmentSettingsImports };

package/dist/commands/pull-v4/generators/external-agent-generator.js

@@ -0,0 +1,56 @@
+import { addStringProperty, createFactoryDefinition, toCamelCase } from "../utils.js";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/generators/external-agent-generator.ts
+const ExternalAgentSchema = z.looseObject({
+	externalAgentId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().nullable().optional(),
+	baseUrl: z.string().nonempty(),
+	credentialReference: z.union([z.string(), z.looseObject({
+		id: z.string().optional(),
+		name: z.string().optional(),
+		description: z.string().optional()
+	})]).optional()
+});
+function generateExternalAgentDefinition(data) {
+	const result = ExternalAgentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for external agent:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "externalAgent",
+		variableName: toCamelCase(parsed.externalAgentId)
+	});
+	if (typeof parsed.credentialReference === "string") sourceFile.addImportDeclaration({
+		namedImports: [toCamelCase(parsed.credentialReference)],
+		moduleSpecifier: `../credentials/${parsed.credentialReference}`
+	});
+	writeExternalAgentConfig(configObject, parsed);
+	return sourceFile;
+}
+function writeExternalAgentConfig(configObject, data) {
+	addStringProperty(configObject, "id", data.externalAgentId);
+	addStringProperty(configObject, "name", data.name);
+	if (data.description !== null && data.description !== void 0) addStringProperty(configObject, "description", data.description);
+	else addStringProperty(configObject, "description", `External agent ${data.externalAgentId}`);
+	addStringProperty(configObject, "baseUrl", data.baseUrl);
+	if (typeof data.credentialReference === "string") {
+		configObject.addPropertyAssignment({
+			name: "credentialReference",
+			initializer: toCamelCase(data.credentialReference)
+		});
+		return;
+	}
+	if (!data.credentialReference) return;
+	const credentialReferenceObject = configObject.addPropertyAssignment({
+		name: "credentialReference",
+		initializer: "{}"
+	}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+	if (data.credentialReference.id !== void 0) addStringProperty(credentialReferenceObject, "id", data.credentialReference.id);
+	if (data.credentialReference.name !== void 0) addStringProperty(credentialReferenceObject, "name", data.credentialReference.name);
+	if (data.credentialReference.description !== void 0) addStringProperty(credentialReferenceObject, "description", data.credentialReference.description);
+}
+
+//#endregion
+export { generateExternalAgentDefinition };

package/dist/commands/pull-v4/generators/function-tool-generator.js

@@ -0,0 +1,48 @@
+import { addValueToObject, createFactoryDefinition, toCamelCase } from "../utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/generators/function-tool-generator.ts
+const FunctionToolSchema = z.looseObject({
+	functionToolId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().optional(),
+	inputSchema: z.unknown().optional(),
+	schema: z.unknown().optional(),
+	executeCode: z.string().optional(),
+	execute: z.string().optional()
+}).superRefine((value, context) => {
+	if (value.inputSchema === void 0 && value.schema === void 0) context.addIssue({
+		code: "custom",
+		message: "inputSchema is required",
+		path: ["inputSchema"]
+	});
+	if (value.executeCode === void 0 && value.execute === void 0) context.addIssue({
+		code: "custom",
+		message: "executeCode is required",
+		path: ["executeCode"]
+	});
+});
+function generateFunctionToolDefinition(data) {
+	const result = FunctionToolSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for function tool:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "functionTool",
+		variableName: toCamelCase(parsed.functionToolId)
+	});
+	writeFunctionToolConfig(configObject, parsed);
+	return sourceFile;
+}
+function writeFunctionToolConfig(configObject, { functionToolId, executeCode, inputSchema, schema, ...rest }) {
+	for (const [k, v] of Object.entries({
+		...rest,
+		inputSchema: inputSchema ?? schema
+	})) addValueToObject(configObject, k, v);
+	if (executeCode) configObject.addPropertyAssignment({
+		name: "execute",
+		initializer: executeCode
+	});
+}
+
+//#endregion
+export { generateFunctionToolDefinition };

package/dist/commands/pull-v4/generators/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/generators/mcp-tool-generator.ts
+const McpToolSchema = z.object({
+	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().nullish(),
+	headers: z.unknown().optional(),
+	credential: z.unknown().optional(),
+	credentialReferenceId: z.string().nullish()
+}).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/generators/project-generator.js

@@ -0,0 +1,125 @@
+import { addReferenceGetterProperty, addValueToObject, convertNullToUndefined, createFactoryDefinition, createUniqueReferenceName, formatStringLiteral, hasReferences, resolveReferenceName, toCamelCase } from "../utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/generators/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 projectVariableName = toCamelCase(parsed.projectId);
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "project",
+		variableName: projectVariableName
+	});
+	const reservedReferenceNames = new Set([projectVariableName]);
+	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)) {
+		const resolvedReferences = createResolvedReferences(agents, referenceOverrides?.agents, reservedReferenceNames, "Agent");
+		addReferenceImports(sourceFile, resolvedReferences, "./agents");
+		addReferenceGetterProperty(configObject, "agents", toReferenceNames(resolvedReferences));
+	}
+	if (hasReferences(tools)) {
+		const resolvedReferences = createResolvedReferences(tools, referenceOverrides?.tools, reservedReferenceNames, "Tool");
+		addReferenceImports(sourceFile, resolvedReferences, "./tools");
+		addReferenceGetterProperty(configObject, "tools", toReferenceNames(resolvedReferences));
+	}
+	if (hasReferences(externalAgents)) {
+		const resolvedReferences = createResolvedReferences(externalAgents, referenceOverrides?.externalAgents, reservedReferenceNames, "ExternalAgent");
+		addReferenceImports(sourceFile, resolvedReferences, "./external-agents");
+		addReferenceGetterProperty(configObject, "externalAgents", toReferenceNames(resolvedReferences));
+	}
+	if (hasReferences(dataComponents)) {
+		const resolvedReferences = createResolvedReferences(dataComponents, referenceOverrides?.dataComponents, reservedReferenceNames, "DataComponent");
+		addReferenceImports(sourceFile, resolvedReferences, "./data-components");
+		addReferenceGetterProperty(configObject, "dataComponents", toReferenceNames(resolvedReferences));
+	}
+	if (hasReferences(artifactComponents)) {
+		const resolvedReferences = createResolvedReferences(artifactComponents, referenceOverrides?.artifactComponents, reservedReferenceNames, "ArtifactComponent");
+		addReferenceImports(sourceFile, resolvedReferences, "./artifact-components");
+		addReferenceGetterProperty(configObject, "artifactComponents", toReferenceNames(resolvedReferences));
+	}
+	if (hasReferences(credentialReferences)) {
+		const resolvedReferences = createResolvedReferences(credentialReferences, referenceOverrides?.credentialReferences, reservedReferenceNames, "CredentialReference");
+		addReferenceImports(sourceFile, resolvedReferences, "./credentials");
+		addReferenceGetterProperty(configObject, "credentialReferences", toReferenceNames(resolvedReferences));
+	}
+	return sourceFile;
+}
+function addReferenceImports(sourceFile, references, basePath) {
+	for (const reference of references) sourceFile.addImportDeclaration({
+		namedImports: [reference.importName === reference.localName ? reference.importName : {
+			name: reference.importName,
+			alias: reference.localName
+		}],
+		moduleSpecifier: `${basePath}/${reference.id}`
+	});
+}
+function toReferenceNames(references) {
+	return references.map((reference) => reference.localName);
+}
+function createResolvedReferences(references, referenceOverrides, reservedReferenceNames, suffix) {
+	const seenIds = /* @__PURE__ */ new Set();
+	const resolvedReferences = [];
+	for (const referenceId of references) {
+		if (seenIds.has(referenceId)) continue;
+		seenIds.add(referenceId);
+		const importName = resolveReferenceName(referenceId, [referenceOverrides]);
+		const localName = createUniqueReferenceName(importName, reservedReferenceNames, suffix);
+		resolvedReferences.push({
+			id: referenceId,
+			importName,
+			localName
+		});
+	}
+	return resolvedReferences;
+}
+
+//#endregion
+export { generateProjectDefinition };

package/dist/commands/{pull-v3/components → pull-v4/generators}/skill-generator.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { stringify } from "yaml";
 import { mkdir, writeFile } from "node:fs/promises";
 
-//#region src/commands/pull-v3/components/skill-generator.ts
+//#region src/commands/pull-v4/generators/skill-generator.ts
 function formatMetadata(metadata) {
 	return `metadata:\n${stringify(metadata).split("\n").filter((line) => line.trim() !== "").map((line) => `  ${line}`).join("\n")}`;
 }

package/dist/commands/pull-v4/generators/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/generators/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 };