@inkeep/agents-cli 0.50.6 → 0.52.0

package/dist/commands/pull-v4/sub-agent-generator.js

@@ -0,0 +1,168 @@
+import { addReferenceGetterProperty, addStringProperty, addValueToObject, collectTemplateVariableNames, convertNullToUndefined, createFactoryDefinition, formatInlineLiteral, formatTemplate, hasReferences, isPlainObject, resolveReferenceName, toCamelCase } from "./utils.js";
+import { FullAgentAgentInsertSchema } from "@inkeep/agents-core";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/sub-agent-generator.ts
+const ReferenceNameByIdSchema = z.record(z.string(), z.string().nonempty());
+const ReferenceOverridesSchema = z.object({
+	tools: ReferenceNameByIdSchema.optional(),
+	subAgents: ReferenceNameByIdSchema.optional(),
+	agents: ReferenceNameByIdSchema.optional(),
+	externalAgents: ReferenceNameByIdSchema.optional(),
+	dataComponents: ReferenceNameByIdSchema.optional(),
+	artifactComponents: ReferenceNameByIdSchema.optional()
+});
+const ContextTemplateReferenceSchema = z.object({
+	name: z.string().nonempty(),
+	local: z.boolean().optional()
+});
+const SubAgentSchema = FullAgentAgentInsertSchema.pick({
+	id: true,
+	description: true,
+	prompt: true
+}).extend({
+	name: z.string().optional(),
+	stopWhen: z.preprocess(convertNullToUndefined, FullAgentAgentInsertSchema.shape.stopWhen),
+	models: z.preprocess(convertNullToUndefined, z.looseObject({}).optional()),
+	skills: z.array(z.unknown()).optional(),
+	canUse: z.array(z.unknown()).optional(),
+	canDelegateTo: z.array(z.unknown()).optional(),
+	canTransferTo: z.array(z.string()).optional(),
+	dataComponents: z.array(z.string()).optional(),
+	artifactComponents: z.array(z.string()).optional(),
+	referenceOverrides: ReferenceOverridesSchema.optional(),
+	contextConfigId: z.string().nonempty().optional(),
+	contextConfigReference: ContextTemplateReferenceSchema.optional(),
+	contextConfigHeadersReference: ContextTemplateReferenceSchema.optional()
+});
+function generateSubAgentDefinition(data) {
+	const result = SubAgentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for sub-agent:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "subAgent",
+		variableName: toCamelCase(parsed.id)
+	});
+	const promptTemplateVariables = typeof parsed.prompt === "string" ? collectTemplateVariableNames(parsed.prompt) : [];
+	const hasContextTemplateVariables = promptTemplateVariables.some((variableName) => !variableName.startsWith("headers."));
+	const hasHeadersTemplateVariables = promptTemplateVariables.some((variableName) => variableName.startsWith("headers."));
+	const namedImports = [];
+	if (hasContextTemplateVariables && parsed.contextConfigId && parsed.contextConfigReference && parsed.contextConfigReference.local !== true) namedImports.push(parsed.contextConfigReference.name);
+	if (hasHeadersTemplateVariables && parsed.contextConfigId && parsed.contextConfigHeadersReference && parsed.contextConfigHeadersReference.local !== true) namedImports.push(parsed.contextConfigHeadersReference.name);
+	if (namedImports.length > 0 && parsed.contextConfigId) sourceFile.addImportDeclaration({
+		namedImports: [...new Set(namedImports)],
+		moduleSpecifier: `../context-configs/${parsed.contextConfigId}`
+	});
+	writeSubAgentConfig(configObject, {
+		contextReference: parsed.contextConfigReference?.name,
+		headersReference: parsed.contextConfigHeadersReference?.name
+	}, parsed);
+	return sourceFile;
+}
+function writeSubAgentConfig(configObject, templateReferences, { dataComponents, name, canDelegateTo, canTransferTo, skills, artifactComponents, canUse, referenceOverrides, contextConfigId: _contextConfigId, contextConfigReference: _contextConfigReference, contextConfigHeadersReference: _contextConfigHeadersReference, ...rest }) {
+	rest = { ...rest };
+	rest.prompt &&= formatTemplate(rest.prompt, templateReferences);
+	for (const [k, v] of Object.entries(rest)) addValueToObject(configObject, k, v);
+	addStringProperty(configObject, "name", resolveSubAgentName(rest.id, name));
+	const canUseReferences = collectCanUseReferences(canUse, referenceOverrides?.tools);
+	if (canUseReferences.length) addReferenceGetterProperty(configObject, "canUse", canUseReferences);
+	const canDelegateToReferences = collectCanDelegateToReferences(canDelegateTo, {
+		subAgents: referenceOverrides?.subAgents,
+		agents: referenceOverrides?.agents,
+		externalAgents: referenceOverrides?.externalAgents
+	});
+	if (canDelegateToReferences.length) addReferenceGetterProperty(configObject, "canDelegateTo", canDelegateToReferences);
+	if (hasReferences(canTransferTo)) addReferenceGetterProperty(configObject, "canTransferTo", canTransferTo.map((id) => resolveReferenceName(id, [
+		referenceOverrides?.subAgents,
+		referenceOverrides?.agents,
+		referenceOverrides?.externalAgents
+	])));
+	if (hasReferences(dataComponents)) addReferenceGetterProperty(configObject, "dataComponents", dataComponents.map((id) => resolveReferenceName(id, [referenceOverrides?.dataComponents])));
+	if (hasReferences(artifactComponents)) addReferenceGetterProperty(configObject, "artifactComponents", artifactComponents.map((id) => resolveReferenceName(id, [referenceOverrides?.artifactComponents])));
+	const collectedSkills = collectSkills(skills);
+	if (collectedSkills.length > 0) {
+		const skillsArray = configObject.addPropertyAssignment({
+			name: "skills",
+			initializer: "() => []"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ArrowFunction).getBody().asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		for (const skill of collectedSkills) skillsArray.addElement(skill);
+	}
+}
+function resolveSubAgentName(subAgentId, name) {
+	if (name !== void 0) return name;
+	return subAgentId.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function collectCanUseReferences(canUse, toolReferenceOverrides) {
+	if (!Array.isArray(canUse)) return [];
+	const references = [];
+	for (const item of canUse) {
+		if (typeof item === "string") {
+			references.push(resolveReferenceName(item, [toolReferenceOverrides]));
+			continue;
+		}
+		if (!isPlainObject(item)) continue;
+		const toolId = typeof item.toolId === "string" ? item.toolId : void 0;
+		if (!toolId) continue;
+		const toolReference = resolveReferenceName(toolId, [toolReferenceOverrides]);
+		const withConfig = {};
+		const selectedTools = Array.isArray(item.toolSelection) && item.toolSelection.length ? item.toolSelection : Array.isArray(item.selectedTools) && item.selectedTools.length ? item.selectedTools : void 0;
+		if (selectedTools) withConfig.selectedTools = selectedTools;
+		if (isPlainObject(item.headers) && Object.keys(item.headers).length) withConfig.headers = item.headers;
+		if (isPlainObject(item.toolPolicies) && Object.keys(item.toolPolicies).length) withConfig.toolPolicies = item.toolPolicies;
+		if (Object.keys(withConfig).length > 0) {
+			references.push(`${toolReference}.with(${formatInlineLiteral(withConfig)})`);
+			continue;
+		}
+		references.push(toolReference);
+	}
+	return references;
+}
+function collectCanDelegateToReferences(canDelegateTo, referenceOverrides) {
+	if (!Array.isArray(canDelegateTo)) return [];
+	const references = [];
+	for (const item of canDelegateTo) {
+		if (typeof item === "string") {
+			references.push(resolveReferenceName(item, [
+				referenceOverrides.subAgents,
+				referenceOverrides.agents,
+				referenceOverrides.externalAgents
+			]));
+			continue;
+		}
+		if (!isPlainObject(item)) continue;
+		const subAgentId = typeof item.subAgentId === "string" ? item.subAgentId : void 0;
+		const agentId = typeof item.agentId === "string" ? item.agentId : void 0;
+		const externalAgentId = typeof item.externalAgentId === "string" ? item.externalAgentId : void 0;
+		const targetId = subAgentId || agentId || externalAgentId;
+		if (!targetId) continue;
+		const targetReference = subAgentId ? resolveReferenceName(subAgentId, [referenceOverrides.subAgents]) : agentId ? resolveReferenceName(agentId, [referenceOverrides.agents]) : resolveReferenceName(targetId, [referenceOverrides.externalAgents]);
+		if (isPlainObject(item.headers) && Object.keys(item.headers).length > 0) {
+			references.push(`${targetReference}.with(${formatInlineLiteral({ headers: item.headers })})`);
+			continue;
+		}
+		references.push(targetReference);
+	}
+	return references;
+}
+function collectSkills(skills) {
+	if (!Array.isArray(skills)) return [];
+	const formattedSkills = [];
+	for (const skill of skills) {
+		if (typeof skill === "string") {
+			formattedSkills.push(formatInlineLiteral(skill));
+			continue;
+		}
+		if (!isPlainObject(skill)) continue;
+		const skillId = typeof skill.id === "string" ? skill.id : typeof skill.skillId === "string" ? skill.skillId : void 0;
+		if (!skillId) continue;
+		const formattedSkill = { id: skillId };
+		if (typeof skill.index === "number" && Number.isInteger(skill.index)) formattedSkill.index = skill.index;
+		if (typeof skill.alwaysLoaded === "boolean") formattedSkill.alwaysLoaded = skill.alwaysLoaded;
+		formattedSkills.push(formatInlineLiteral(formattedSkill));
+	}
+	return formattedSkills;
+}
+
+//#endregion
+export { generateSubAgentDefinition };

package/dist/commands/pull-v4/trigger-generator.js

@@ -0,0 +1,58 @@
+import { addValueToObject, createFactoryDefinition, toCamelCase } from "./utils.js";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/trigger-generator.ts
+const TriggerSchema = z.looseObject({
+	triggerId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().optional(),
+	enabled: z.boolean().optional(),
+	messageTemplate: z.string().nonempty(),
+	inputSchema: z.unknown().optional(),
+	outputTransform: z.looseObject({
+		jmespath: z.string().optional(),
+		objectTransformation: z.unknown().optional()
+	}).optional(),
+	authentication: z.looseObject({ headers: z.array(z.looseObject({})).optional() }).optional(),
+	signatureVerification: z.looseObject({
+		algorithm: z.string().optional(),
+		encoding: z.string().optional(),
+		signature: z.looseObject({}).optional(),
+		signedComponents: z.array(z.looseObject({})).optional(),
+		componentJoin: z.looseObject({}).optional(),
+		validation: z.looseObject({}).optional()
+	}).optional(),
+	signingSecretCredentialReferenceId: z.string().optional(),
+	signingSecretCredentialReference: z.union([z.string(), z.looseObject({ id: z.string().optional() })]).optional()
+});
+function generateTriggerDefinition(data) {
+	const result = TriggerSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for trigger:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "Trigger",
+		variableName: toCamelCase(parsed.triggerId),
+		syntaxKind: SyntaxKind.NewExpression
+	});
+	const { triggerId, signingSecretCredentialReferenceId, ...rest } = parsed;
+	for (const [key, value] of Object.entries({
+		id: triggerId,
+		...rest
+	})) addValueToObject(configObject, key, value);
+	if (signingSecretCredentialReferenceId) {
+		const varName = toCamelCase(signingSecretCredentialReferenceId);
+		sourceFile.addImportDeclaration({
+			namedImports: [varName],
+			moduleSpecifier: `../../credentials/${signingSecretCredentialReferenceId}`
+		});
+		configObject.addPropertyAssignment({
+			name: "signingSecretCredentialReference",
+			initializer: varName
+		});
+	}
+	return sourceFile;
+}
+
+//#endregion
+export { generateTriggerDefinition };

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

@@ -0,0 +1,219 @@
+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 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, 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();

package/dist/index.js

@@ -9,32 +9,28 @@ import { initCommand } from "./commands/init.js";
 import { listAgentsCommand } from "./commands/list-agents.js";
 import { logoutCommand } from "./commands/logout.js";
 import { profileAddCommand, profileCurrentCommand, profileListCommand, profileRemoveCommand, profileUseCommand } from "./commands/profile.js";
-import { pullV3Command } from "./commands/pull-v3/index.js";
+import { PACKAGE_VERSION } from "./utils/version-check.js";
+import { pullV4Command } from "./commands/pull-v4/introspect/index.js";
 import { pushCommand } from "./commands/push.js";
 import { statusCommand } from "./commands/status.js";
 import { updateCommand } from "./commands/update.js";
 import { whoamiCommand } from "./commands/whoami.js";
 import { getLogger } from "@inkeep/agents-core";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
 //#region src/index.ts
 getLogger("config").updateOptions({ level: "silent" });
-const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 const program = new Command();
-program.name("inkeep").description("CLI tool for Inkeep Agent Framework").version(packageJson.version);
+program.name("inkeep").description("CLI tool for Inkeep Agent Framework").version(PACKAGE_VERSION);
 program.command("add [template]").description("Add a new template to the project").option("--project <template>", "Project template to add").option("--mcp <template>", "MCP template to add").option("--ui [component-id]", "Add UI component(s) to apps/agents-ui/src/ui (omit id to add all)").option("--list", "List available UI components (use with --ui)").option("--target-path <path>", "Target path to add the template to").option("--local-prefix <path_prefix>", "Use local templates from the given path prefix").option("--config <path>", "Path to configuration file").option("--profile <name>", "Profile to use for authentication").option("--quiet", "Suppress profile/config logging").action(async (template, options) => {
 	await addCommand({
 		template,
 		...options
 	});
 });
-program.command("init [path]").description("Initialize a new Inkeep project (runs cloud onboarding wizard by default)").option("--local", "Use local/self-hosted mode instead of cloud onboarding").option("--no-interactive", "Skip interactive prompts").option("--config <path>", "Path to use as template for new configuration").action(async (path$1, options) => {
+program.command("init [path]").description("Initialize a new Inkeep project (runs cloud onboarding wizard by default)").option("--local", "Use local/self-hosted mode instead of cloud onboarding").option("--no-interactive", "Skip interactive prompts").option("--config <path>", "Path to use as template for new configuration").action(async (path, options) => {
 	await initCommand({
-		path: path$1,
+		path,
 		...options
 	});
 });
@@ -48,11 +44,9 @@ configCommand.command("set <key> <value>").description("Set a configuration valu
 configCommand.command("list").description("List all configuration values").option("--config <path>", "Path to configuration file").option("--config-file-path <path>", "Path to configuration file (deprecated, use --config)").action(async (options) => {
 	await configListCommand({ config: options.config || options.configFilePath });
 });
-program.command("push").description("Push a project configuration to the backend").option("--project <project-id>", "Project ID or path to project directory").option("--config <path>", "Path to configuration file").option("--profile <name>", "Profile to use for remote URLs and authentication").option("--tenant-id <id>", "Override tenant ID").option("--agents-api-url <url>", "Override agents API URL").option("--env <environment>", "Environment to use for credential resolution (e.g., development, production)").option("--json", "Generate project data JSON file instead of pushing to backend").option("--all", "Push all projects found in current directory tree").option("--tag <tag>", "Use tagged config file (e.g., --tag prod loads prod.__inkeep.config.ts__)").option("--quiet", "Suppress profile/config logging").action(async (options) => {
-	await pushCommand(options);
-});
-program.command("pull").description("Pull project configuration with clean, efficient code generation").option("--project <project-id>", "Project ID to pull (or path to project directory). If in project directory, validates against local project ID.").option("--config <path>", "Path to configuration file").option("--profile <name>", "Profile to use for remote URLs and authentication").option("--env <environment>", "Environment file to generate (development, staging, production). Defaults to development").option("--json", "Output project data as JSON instead of generating files").option("--debug", "Enable debug logging").option("--verbose", "Enable verbose logging").option("--force", "Force regeneration even if no changes detected").option("--introspect", "Completely regenerate all files from scratch (no comparison needed)").option("--all", "Pull all projects for current tenant").option("--tag <tag>", "Use tagged config file (e.g., --tag prod loads prod.__inkeep.config.ts__)").option("--quiet", "Suppress profile/config logging").action(async (options) => {
-	await pullV3Command(options);
+program.command("push").description("Push a project configuration to the backend").option("--project <project-id>", "Project ID or path to project directory").option("--config <path>", "Path to configuration file").option("--profile <name>", "Profile to use for remote URLs and authentication").option("--tenant-id <id>", "Override tenant ID").option("--agents-api-url <url>", "Override agents API URL").option("--env <environment>", "Environment to use for credential resolution (e.g., development, production)").option("--json", "Generate project data JSON file instead of pushing to backend").option("--all", "Push all projects found in current directory tree").option("--tag <tag>", "Use tagged config file (e.g., --tag prod loads prod.__inkeep.config.ts__)").option("--quiet", "Suppress profile/config logging").action(pushCommand);
+program.command("pull").description("Pull project configuration with clean, efficient code generation").option("--project <project-id>", "Project ID to pull (or path to project directory). If in project directory, validates against local project ID.").option("--config <path>", "Path to configuration file").option("--profile <name>", "Profile to use for remote URLs and authentication").option("--env <environment>", "Environment file to generate (development, staging, production). Defaults to development").option("--json", "Output project data as JSON instead of generating files").option("--debug", "Enable debug logging").option("--verbose", "Enable verbose logging").option("--force", "Force regeneration even if no changes detected").option("--all", "Pull all projects for current tenant").option("--tag <tag>", "Use tagged config file (e.g., --tag prod loads prod.__inkeep.config.ts__)").option("--quiet", "Suppress profile/config logging").action(async (options) => {
+	await pullV4Command(options);
 });
 program.command("list-agent").description("List all available agents for a specific project").requiredOption("--project <project-id>", "Project ID to list agent for").option("--tenant-id <tenant-id>", "Tenant ID").option("--agents-api-url <url>", "Agents API URL").option("--config <path>", "Path to configuration file").option("--config-file-path <path>", "Path to configuration file (deprecated, use --config)").action(async (options) => {
 	const config = options.config || options.configFilePath;
@@ -72,37 +66,17 @@ program.command("dev").description("Start the Inkeep dashboard server").option("
 		openBrowser: options.openBrowser
 	});
 });
-program.command("update").description("Update @inkeep/agents-cli to the latest version").option("--check", "Check for updates without installing").option("--force", "Force update even if already on latest version").action(async (options) => {
-	await updateCommand(options);
-});
-program.command("login").description("Authenticate with Inkeep Cloud").option("--profile <name>", "Profile to authenticate (defaults to active profile)").action(async (options) => {
-	await loginCommand(options);
-});
-program.command("logout").description("Log out of Inkeep Cloud").option("--profile <name>", "Profile to log out (defaults to active profile)").action(async (options) => {
-	await logoutCommand(options);
-});
-program.command("status").description("Show current profile, authentication state, and remote URLs").option("--profile <name>", "Profile to show status for (defaults to active profile)").action(async (options) => {
-	await statusCommand(options);
-});
-program.command("whoami").description("Display current authentication status (alias for status)").action(async () => {
-	await whoamiCommand();
-});
+program.command("update").description("Update @inkeep/agents-cli to the latest version").option("--check", "Check for updates without installing").option("--force", "Force update even if already on latest version").action(updateCommand);
+program.command("login").description("Authenticate with Inkeep Cloud").option("--profile <name>", "Profile to authenticate (defaults to active profile)").action(loginCommand);
+program.command("logout").description("Log out of Inkeep Cloud").option("--profile <name>", "Profile to log out (defaults to active profile)").action(logoutCommand);
+program.command("status").description("Show current profile, authentication state, and remote URLs").option("--profile <name>", "Profile to show status for (defaults to active profile)").action(statusCommand);
+program.command("whoami").description("Display current authentication status (alias for status)").action(whoamiCommand);
 const profileCommand = program.command("profile").description("Manage CLI profiles for connecting to different remotes");
-profileCommand.command("list").description("List all profiles").action(async () => {
-	await profileListCommand();
-});
-profileCommand.command("add [name]").description("Add a new profile").action(async (name) => {
-	await profileAddCommand(name);
-});
-profileCommand.command("use <name>").description("Set the active profile").action(async (name) => {
-	await profileUseCommand(name);
-});
-profileCommand.command("current").description("Display the active profile details").action(async () => {
-	await profileCurrentCommand();
-});
-profileCommand.command("remove <name>").description("Remove a profile").action(async (name) => {
-	await profileRemoveCommand(name);
-});
+profileCommand.command("list").description("List all profiles").action(profileListCommand);
+profileCommand.command("add [name]").description("Add a new profile").action(profileAddCommand);
+profileCommand.command("use <name>").description("Set the active profile").action(profileUseCommand);
+profileCommand.command("current").description("Display the active profile details").action(profileCurrentCommand);
+profileCommand.command("remove <name>").description("Remove a profile").action(profileRemoveCommand);
 program.parse();
 
 //#endregion

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/array.js

@@ -0,0 +1,18 @@
+import Diff from "./base.js";
+
+//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/array.js
+var ArrayDiff = class extends Diff {
+	tokenize(value) {
+		return value.slice();
+	}
+	join(value) {
+		return value;
+	}
+	removeEmpty(value) {
+		return value;
+	}
+};
+const arrayDiff = new ArrayDiff();
+
+//#endregion
+export {  };