@inkeep/agents-cli 0.39.5 → 0.41.0

package/dist/commands/pull-v3/project-comparator.js

@@ -0,0 +1,914 @@
+import { compareJsonObjects } from "../../utils/json-comparator.js";
+import chalk from "chalk";
+
+//#region src/commands/pull-v3/project-comparator.ts
+/**
+* Compare two projects and classify all changes using direct component comparison
+*/
+async function compareProjects(localProject, remoteProject, localRegistry, debug = false) {
+	if (debug) console.log(chalk.gray("\n🔍 Comparing local and remote projects..."));
+	if (!localProject) return createNewProjectComparison(remoteProject, debug);
+	const changes = compareComponentsDirectly(localProject, remoteProject, localRegistry, debug);
+	const componentChanges = groupChangesByType(changes);
+	return {
+		hasChanges: changes.length > 0,
+		changeCount: changes.length,
+		changes,
+		rawDifferences: [],
+		componentChanges
+	};
+}
+/**
+* Handle new project case (everything is added)
+*/
+function createNewProjectComparison(project, debug) {
+	const changes = [];
+	if (project.agents) Object.keys(project.agents).forEach((agentId) => {
+		changes.push({
+			componentType: "agents",
+			componentId: agentId,
+			changeType: "added"
+		});
+	});
+	if (project.tools) Object.keys(project.tools).forEach((toolId) => {
+		changes.push({
+			componentType: "tools",
+			componentId: toolId,
+			changeType: "added"
+		});
+	});
+	if (project.functionTools) Object.keys(project.functionTools).forEach((toolId) => {
+		changes.push({
+			componentType: "functionTools",
+			componentId: toolId,
+			changeType: "added"
+		});
+	});
+	if (project.functions) Object.keys(project.functions).forEach((funcId) => {
+		changes.push({
+			componentType: "functions",
+			componentId: funcId,
+			changeType: "added"
+		});
+	});
+	if (project.dataComponents) Object.keys(project.dataComponents).forEach((componentId) => {
+		changes.push({
+			componentType: "dataComponents",
+			componentId,
+			changeType: "added"
+		});
+	});
+	if (project.artifactComponents) Object.keys(project.artifactComponents).forEach((componentId) => {
+		changes.push({
+			componentType: "artifactComponents",
+			componentId,
+			changeType: "added"
+		});
+	});
+	if (project.agents) Object.entries(project.agents).forEach(([agentId, agentData]) => {
+		if (agentData.subAgents) Object.keys(agentData.subAgents).forEach((subAgentId) => {
+			changes.push({
+				componentType: "subAgents",
+				componentId: subAgentId,
+				changeType: "added"
+			});
+		});
+	});
+	extractStatusComponentIds(project).forEach((componentId) => {
+		changes.push({
+			componentType: "statusComponents",
+			componentId,
+			changeType: "added"
+		});
+	});
+	if (project.agents) Object.entries(project.agents).forEach(([agentId, agentData]) => {
+		if (agentData.contextConfig) {
+			const contextConfigId = agentData.contextConfig.id;
+			if (!contextConfigId) return;
+			changes.push({
+				componentType: "contextConfigs",
+				componentId: contextConfigId,
+				changeType: "added"
+			});
+		}
+	});
+	if (project.externalAgents) Object.keys(project.externalAgents).forEach((extAgentId) => {
+		changes.push({
+			componentType: "externalAgents",
+			componentId: extAgentId,
+			changeType: "added"
+		});
+	});
+	if (project.credentialReferences) Object.keys(project.credentialReferences).forEach((credId) => {
+		changes.push({
+			componentType: "credentials",
+			componentId: credId,
+			changeType: "added"
+		});
+	});
+	const componentChanges = groupChangesByType(changes);
+	return {
+		hasChanges: true,
+		changeCount: changes.length,
+		changes,
+		rawDifferences: [],
+		componentChanges
+	};
+}
+/**
+* Direct component-by-component comparison
+*/
+function compareComponentsDirectly(localProject, remoteProject, localRegistry, debug) {
+	const changes = [];
+	changes.push(...compareAgents(localProject.agents || {}, remoteProject.agents || {}, debug));
+	changes.push(...compareSubAgents(localProject.agents || {}, remoteProject.agents || {}, debug));
+	changes.push(...compareTools(localProject.tools || {}, remoteProject.tools || {}, debug));
+	changes.push(...compareFunctionTools(localProject.functionTools || {}, remoteProject.functionTools || {}, debug));
+	changes.push(...compareFunctions(localProject.functions || {}, remoteProject.functions || {}, debug));
+	changes.push(...compareDataComponents(localProject.dataComponents || {}, remoteProject.dataComponents || {}, debug));
+	changes.push(...compareArtifactComponents(localProject.artifactComponents || {}, remoteProject.artifactComponents || {}, debug));
+	changes.push(...compareCredentials(localProject.credentialReferences || {}, remoteProject.credentialReferences || {}, debug));
+	changes.push(...compareExternalAgents(localProject.externalAgents || {}, remoteProject.externalAgents || {}, debug));
+	const localStatusComponents = extractStatusComponentsFromProject(localProject);
+	const remoteStatusComponents = extractStatusComponentsFromProject(remoteProject);
+	changes.push(...compareStatusComponents(localStatusComponents, remoteStatusComponents, debug));
+	changes.push(...compareContextConfigs(localProject, remoteProject, localRegistry, debug));
+	changes.push(...compareFetchDefinitions(localProject, remoteProject, debug));
+	changes.push(...compareProjectModels(localProject.models, remoteProject.models, debug));
+	changes.push(...compareProjectFields(localProject, remoteProject, debug));
+	return changes;
+}
+/**
+* Compare agents between local and remote
+*/
+function compareAgents(localAgents, remoteAgents, debug) {
+	const changes = [];
+	const localIds = Object.keys(localAgents);
+	const remoteIds = Object.keys(remoteAgents);
+	remoteIds.filter((id) => !localIds.includes(id)).forEach((id) => {
+		const agent = remoteAgents[id];
+		changes.push({
+			componentType: "agents",
+			componentId: id,
+			changeType: "added",
+			summary: `New agent: ${agent.name || id}`
+		});
+	});
+	localIds.filter((id) => !remoteIds.includes(id)).forEach((id) => {
+		const agent = localAgents[id];
+		changes.push({
+			componentType: "agents",
+			componentId: id,
+			changeType: "deleted",
+			summary: `Removed agent: ${agent.name || id}`
+		});
+	});
+	localIds.filter((id) => remoteIds.includes(id)).forEach((id) => {
+		const fieldChanges = getDetailedFieldChanges("", localAgents[id], remoteAgents[id]);
+		if (fieldChanges.length > 0) {
+			const summary = generateAgentChangeSummary(fieldChanges);
+			changes.push({
+				componentType: "agents",
+				componentId: id,
+				changeType: "modified",
+				changedFields: fieldChanges,
+				summary
+			});
+		}
+	});
+	return changes;
+}
+/**
+* Compare subAgents between local and remote
+* Extracts subAgents from all agents and compares them as separate components
+*/
+function compareSubAgents(localAgents, remoteAgents, debug) {
+	const changes = [];
+	const localSubAgents = {};
+	for (const [agentId, agentData] of Object.entries(localAgents)) if (agentData.subAgents) for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) localSubAgents[subAgentId] = subAgentData;
+	const remoteSubAgents = {};
+	for (const [agentId, agentData] of Object.entries(remoteAgents)) if (agentData.subAgents) for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) remoteSubAgents[subAgentId] = subAgentData;
+	const localIds = Object.keys(localSubAgents);
+	const remoteIds = Object.keys(remoteSubAgents);
+	remoteIds.filter((id) => !localIds.includes(id)).forEach((id) => {
+		const subAgent = remoteSubAgents[id];
+		changes.push({
+			componentType: "subAgents",
+			componentId: id,
+			changeType: "added",
+			summary: `New subAgent: ${subAgent.name || id}`
+		});
+	});
+	localIds.filter((id) => !remoteIds.includes(id)).forEach((id) => {
+		const subAgent = localSubAgents[id];
+		changes.push({
+			componentType: "subAgents",
+			componentId: id,
+			changeType: "deleted",
+			summary: `Removed subAgent: ${subAgent.name || id}`
+		});
+	});
+	localIds.filter((id) => remoteIds.includes(id)).forEach((id) => {
+		const fieldChanges = getDetailedFieldChanges("", localSubAgents[id], remoteSubAgents[id]);
+		if (fieldChanges.length > 0) {
+			const summary = generateSubAgentChangeSummary(fieldChanges);
+			changes.push({
+				componentType: "subAgents",
+				componentId: id,
+				changeType: "modified",
+				changedFields: fieldChanges,
+				summary
+			});
+		}
+	});
+	return changes;
+}
+/**
+* Generate a summary for subAgent changes
+*/
+function generateSubAgentChangeSummary(fieldChanges) {
+	const changeTypes = new Set(fieldChanges.map((c) => c.changeType));
+	const fieldNames = fieldChanges.map((c) => c.field.split(".")[0]).filter((value, index, self) => self.indexOf(value) === index);
+	if (changeTypes.has("modified") && fieldNames.length === 1) return `Modified ${fieldNames[0]}`;
+	if (changeTypes.has("added") && changeTypes.has("deleted")) return `Updated configuration (${fieldChanges.length} changes)`;
+	if (changeTypes.has("added")) return `Added ${fieldNames.join(", ")}`;
+	if (changeTypes.has("deleted")) return `Removed ${fieldNames.join(", ")}`;
+	return `Modified ${fieldNames.join(", ")}`;
+}
+/**
+* Compare tools between local and remote
+*/
+function compareTools(localTools, remoteTools, debug) {
+	return compareComponentMaps("tools", localTools, remoteTools, debug);
+}
+/**
+* Compare function tools between local and remote
+*/
+function compareFunctionTools(localFunctionTools, remoteFunctionTools, debug) {
+	return compareComponentMaps("functionTools", localFunctionTools, remoteFunctionTools, debug);
+}
+/**
+* Compare functions between local and remote
+*/
+function compareFunctions(localFunctions, remoteFunctions, debug) {
+	const cleanLocalFunctions = {};
+	const cleanRemoteFunctions = {};
+	for (const [id, func] of Object.entries(localFunctions)) cleanLocalFunctions[id] = {
+		id: func.id,
+		inputSchema: func.inputSchema,
+		executeCode: func.executeCode,
+		dependencies: func.dependencies
+	};
+	for (const [id, func] of Object.entries(remoteFunctions)) cleanRemoteFunctions[id] = {
+		id: func.id,
+		inputSchema: func.inputSchema,
+		executeCode: func.executeCode,
+		dependencies: func.dependencies
+	};
+	return compareComponentMaps("functions", cleanLocalFunctions, cleanRemoteFunctions, debug);
+}
+/**
+* Compare data components between local and remote
+*/
+function compareDataComponents(localDataComponents, remoteDataComponents, debug) {
+	return compareComponentMaps("dataComponents", localDataComponents, remoteDataComponents, debug);
+}
+/**
+* Compare artifact components between local and remote
+*/
+function compareArtifactComponents(localArtifactComponents, remoteArtifactComponents, debug) {
+	return compareComponentMaps("artifactComponents", localArtifactComponents, remoteArtifactComponents, debug);
+}
+/**
+* Compare credentials between local and remote
+*/
+function compareCredentials(localCredentials, remoteCredentials, debug) {
+	return compareComponentMaps("credentials", localCredentials, remoteCredentials, debug);
+}
+/**
+* Compare external agents between local and remote
+*/
+function compareExternalAgents(localExternalAgents, remoteExternalAgents, debug) {
+	return compareComponentMaps("externalAgents", localExternalAgents, remoteExternalAgents, debug);
+}
+/**
+* Compare status components between local and remote
+*/
+function compareStatusComponents(localStatusComponents, remoteStatusComponents, debug) {
+	return compareComponentMaps("statusComponents", localStatusComponents, remoteStatusComponents, debug);
+}
+/**
+* Compare project-level models
+*/
+function compareProjectModels(localModels, remoteModels, debug) {
+	const changes = [];
+	const fieldChanges = getDetailedFieldChanges("", localModels, remoteModels);
+	if (fieldChanges.length > 0) {
+		const summary = generateModelsChangeSummary(fieldChanges);
+		changes.push({
+			componentType: "models",
+			componentId: "project",
+			changeType: "modified",
+			changedFields: fieldChanges,
+			summary
+		});
+	}
+	return changes;
+}
+/**
+* Generate summary for model changes
+*/
+function generateModelsChangeSummary(fieldChanges) {
+	const modelTypes = [];
+	fieldChanges.forEach((change) => {
+		const field = change.field;
+		if (field.includes("base")) modelTypes.push("base model");
+		else if (field.includes("structuredOutput")) modelTypes.push("structured output model");
+		else if (field.includes("model")) modelTypes.push("model configuration");
+	});
+	const uniqueTypes = [...new Set(modelTypes)];
+	if (uniqueTypes.length > 0) return `Updated ${uniqueTypes.join(", ")}`;
+	return `${fieldChanges.length} model configuration changes`;
+}
+/**
+* Compare project-level fields like name, description, etc.
+*/
+function compareProjectFields(localProject, remoteProject, debug) {
+	const changes = [];
+	for (const field of [
+		"name",
+		"description",
+		"stopWhen"
+	]) {
+		const oldValue = localProject[field];
+		const newValue = remoteProject[field];
+		if (!deepEqual(oldValue, newValue)) {
+			const fieldChanges = getDetailedFieldChanges("", oldValue, newValue);
+			if (fieldChanges.length > 0) {
+				const summary = `Project ${field} updated`;
+				changes.push({
+					componentType: "contextConfigs",
+					componentId: `project-${field}`,
+					changeType: "modified",
+					changedFields: fieldChanges,
+					summary
+				});
+			}
+		}
+	}
+	return changes;
+}
+/**
+* Generic component map comparison with detailed field tracking
+*/
+function compareComponentMaps(componentType, localMap, remoteMap, debug) {
+	const changes = [];
+	const localIds = Object.keys(localMap);
+	const remoteIds = Object.keys(remoteMap);
+	remoteIds.filter((id) => !localIds.includes(id)).forEach((id) => {
+		const component = remoteMap[id];
+		const summary = generateComponentSummary(componentType, "added", component);
+		changes.push({
+			componentType,
+			componentId: id,
+			changeType: "added",
+			summary
+		});
+	});
+	localIds.filter((id) => !remoteIds.includes(id)).forEach((id) => {
+		const component = localMap[id];
+		const summary = generateComponentSummary(componentType, "deleted", component);
+		changes.push({
+			componentType,
+			componentId: id,
+			changeType: "deleted",
+			summary
+		});
+	});
+	localIds.filter((id) => remoteIds.includes(id)).forEach((id) => {
+		if (componentType === "artifactComponents") {
+			if (!compareJsonObjects(localMap[id], remoteMap[id], {
+				ignoreArrayOrder: true,
+				showDetails: false
+			}).isEqual) changes.push({
+				componentType,
+				componentId: id,
+				changeType: "modified",
+				summary: `Modified ${componentType}: ${id}`
+			});
+		} else {
+			const fieldChanges = getDetailedFieldChanges("", localMap[id], remoteMap[id]);
+			if (fieldChanges.length > 0) {
+				const summary = generateComponentChangeSummary(componentType, fieldChanges);
+				changes.push({
+					componentType,
+					componentId: id,
+					changeType: "modified",
+					changedFields: fieldChanges,
+					summary
+				});
+			}
+		}
+	});
+	return changes;
+}
+/**
+* Check if a value is considered "empty" (null, undefined, empty array, empty object)
+*/
+function isEmpty(value) {
+	if (value === null || value === void 0) return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	if (typeof value === "object" && value !== null && Object.keys(value).length === 0) return true;
+	return false;
+}
+/**
+* Compare arrays as sets (order-independent) using a key function to identify items
+*/
+function compareArraysAsSet(basePath, oldArray, newArray, depth) {
+	const changes = [];
+	const getItemKey = (item) => {
+		if (typeof item === "string") return item;
+		if (typeof item === "object" && item !== null) {
+			if (item.toolId) return `tool:${item.toolId}`;
+			if (item.agentId) return `agent:${item.agentId}`;
+			if (item.externalAgentId) return `external:${item.externalAgentId}`;
+			if (item.subAgentId) return `subagent:${item.subAgentId}`;
+			if (item.id) return item.id;
+			if (item.type) return `type:${item.type}`;
+			return JSON.stringify(item);
+		}
+		return String(item);
+	};
+	const oldMap = /* @__PURE__ */ new Map();
+	const newMap = /* @__PURE__ */ new Map();
+	oldArray.forEach((item, index) => {
+		const key = getItemKey(item);
+		oldMap.set(key, {
+			item,
+			index
+		});
+	});
+	newArray.forEach((item, index) => {
+		const key = getItemKey(item);
+		newMap.set(key, {
+			item,
+			index
+		});
+	});
+	for (const [key, { item }] of newMap) if (!oldMap.has(key)) changes.push({
+		field: `${basePath}[+${key}]`,
+		changeType: "added",
+		newValue: item,
+		description: `Added array item: ${formatValue(item)}`
+	});
+	for (const [key, { item }] of oldMap) if (!newMap.has(key)) changes.push({
+		field: `${basePath}[-${key}]`,
+		changeType: "deleted",
+		oldValue: item,
+		description: `Removed array item: ${formatValue(item)}`
+	});
+	for (const [key, { item: newItem }] of newMap) if (oldMap.has(key)) {
+		const { item: oldItem } = oldMap.get(key);
+		const itemChanges = getDetailedFieldChanges(`${basePath}[${key}]`, oldItem, newItem, depth + 1);
+		changes.push(...itemChanges);
+	}
+	return changes;
+}
+/**
+* Extract credential IDs from an agent object, handling different storage structures
+*/
+function extractCredentialIds(agentObj) {
+	const credentialIds = [];
+	if (agentObj.credentials && Array.isArray(agentObj.credentials)) agentObj.credentials.forEach((cred) => {
+		if (cred.id) credentialIds.push(cred.id);
+	});
+	if (agentObj.contextConfig?.contextVariables) Object.values(agentObj.contextConfig.contextVariables).forEach((variable) => {
+		if (variable && typeof variable === "object" && variable.credentialReferenceId) credentialIds.push(variable.credentialReferenceId);
+	});
+	return [...new Set(credentialIds)];
+}
+/**
+* Get detailed field-level changes between two objects
+*/
+function getDetailedFieldChanges(basePath, oldObj, newObj, depth = 0) {
+	const changes = [];
+	if (depth > 10) return changes;
+	const ignoredFields = [
+		"_agentId",
+		"_parentAgentId",
+		"_contextConfigData",
+		"type",
+		"tenantId",
+		"projectId",
+		"agentId",
+		"lastError",
+		"contextConfig.id",
+		"lastErrorAt",
+		"status",
+		"usedBy",
+		"tools",
+		"createdAt",
+		"updatedAt"
+	];
+	const oldIsEmpty = isEmpty(oldObj);
+	const newIsEmpty = isEmpty(newObj);
+	if (oldIsEmpty && newIsEmpty) return changes;
+	if (oldIsEmpty && !newIsEmpty) {
+		const fieldPath = basePath || "root";
+		changes.push({
+			field: fieldPath,
+			changeType: "added",
+			oldValue: oldObj,
+			newValue: newObj,
+			description: `Added: ${formatValue(newObj)}`
+		});
+		return changes;
+	}
+	if (!oldIsEmpty && newIsEmpty) {
+		const fieldPath = basePath || "root";
+		changes.push({
+			field: fieldPath,
+			changeType: "deleted",
+			oldValue: oldObj,
+			newValue: newObj,
+			description: `Removed: ${formatValue(oldObj)}`
+		});
+		return changes;
+	}
+	if (Array.isArray(oldObj) && Array.isArray(newObj)) {
+		if (basePath.endsWith("canDelegateTo")) return compareArraysAsSet(basePath, normalizeCanDelegateTo(oldObj), normalizeCanDelegateTo(newObj), depth);
+		return compareArraysAsSet(basePath, oldObj, newObj, depth);
+	}
+	if (typeof oldObj === "object" && typeof newObj === "object") {
+		const oldKeys = Object.keys(oldObj);
+		const newKeys = Object.keys(newObj);
+		const allKeys = [...new Set([...oldKeys, ...newKeys])];
+		for (const key of allKeys) {
+			const fieldPath = basePath ? `${basePath}.${key}` : key;
+			if (ignoredFields.some((ignored) => {
+				if (fieldPath === ignored) return true;
+				if (key === ignored) return true;
+				if (ignored.includes(".") && fieldPath === ignored) return true;
+				return false;
+			})) continue;
+			if (key === "credentials" && basePath === "") {
+				const oldCredIds = extractCredentialIds(oldObj);
+				const newCredIds = extractCredentialIds(newObj);
+				oldCredIds.sort();
+				newCredIds.sort();
+				if (JSON.stringify(oldCredIds) !== JSON.stringify(newCredIds)) changes.push({
+					field: fieldPath,
+					changeType: "modified",
+					oldValue: oldCredIds,
+					newValue: newCredIds,
+					description: `Credential usage differs: [${oldCredIds.join(", ")}] vs [${newCredIds.join(", ")}]`
+				});
+				continue;
+			}
+			const oldValue = oldObj[key];
+			const newValue = newObj[key];
+			if (!(key in oldObj)) {
+				if (!isEmpty(newValue)) changes.push({
+					field: fieldPath,
+					changeType: "added",
+					newValue,
+					description: `Added field: ${formatValue(newValue)}`
+				});
+			} else if (!(key in newObj)) {
+				if (!isEmpty(oldValue)) changes.push({
+					field: fieldPath,
+					changeType: "deleted",
+					oldValue,
+					description: `Removed field: ${formatValue(oldValue)}`
+				});
+			} else {
+				const oldIsEmpty$1 = isEmpty(oldValue);
+				const newIsEmpty$1 = isEmpty(newValue);
+				if (oldIsEmpty$1 && newIsEmpty$1) continue;
+				if (key === "models") {
+					if ((oldValue === null || oldValue === void 0) !== (newValue === null || newValue === void 0)) continue;
+				}
+				const recursiveChanges = getDetailedFieldChanges(fieldPath, oldValue, newValue, depth + 1);
+				changes.push(...recursiveChanges);
+			}
+		}
+		return changes;
+	}
+	if (oldObj !== newObj) {
+		const fieldPath = basePath || "value";
+		changes.push({
+			field: fieldPath,
+			changeType: "modified",
+			oldValue: oldObj,
+			newValue: newObj,
+			description: `Changed from ${formatValue(oldObj)} to ${formatValue(newObj)}`
+		});
+	}
+	return changes;
+}
+/**
+* Format a value for display in change descriptions
+*/
+function formatValue(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") {
+		if (value.length > 50) return `"${value.substring(0, 47)}..."`;
+		return `"${value}"`;
+	}
+	if (typeof value === "object") {
+		if (Array.isArray(value)) {
+			if (value.length === 0) return "[]";
+			if (value.length === 1) {
+				const firstItem$1 = value[0];
+				if (typeof firstItem$1 === "object" && firstItem$1 !== null) {
+					const keys$1 = Object.keys(firstItem$1);
+					if (keys$1.length > 0) return `[{${keys$1.slice(0, 2).join(", ")}${keys$1.length > 2 ? ", ..." : ""}}]`;
+				}
+				return `["${String(firstItem$1).substring(0, 20)}..."]`;
+			}
+			const firstItem = value[0];
+			if (typeof firstItem === "object" && firstItem !== null) return `[{${Object.keys(firstItem).slice(0, 2).join(", ")}}, ...] (${value.length} items)`;
+			return `[${value.length} items]`;
+		}
+		if (Object.keys(value).length === 0) return "{}";
+		const keys = Object.keys(value);
+		if (keys.length <= 3) return `{${keys.map((key) => {
+			const val = value[key];
+			if (typeof val === "string") return `${key}: "${val.length > 15 ? val.substring(0, 12) + "..." : val}"`;
+			if (typeof val === "object" && val !== null) return `${key}: {...}`;
+			return `${key}: ${val}`;
+		}).join(", ")}}`;
+		if (keys.length <= 5) return `{${keys.join(", ")}}`;
+		return `{${keys.slice(0, 3).join(", ")}, ...} (${keys.length} fields)`;
+	}
+	return String(value);
+}
+/**
+* Generate human-readable summary for agent changes
+*/
+function generateAgentChangeSummary(fieldChanges) {
+	const summaryParts = [];
+	const nameChange = fieldChanges.find((c) => c.field === "name");
+	const promptChange = fieldChanges.find((c) => c.field === "prompt");
+	const modelChanges = fieldChanges.filter((c) => c.field.startsWith("models"));
+	const toolChanges = fieldChanges.filter((c) => c.field.includes("canUse") || c.field.includes("tools"));
+	const subAgentChanges = fieldChanges.filter((c) => c.field.includes("subAgents") || c.field.includes("canDelegateTo"));
+	if (nameChange) summaryParts.push("name updated");
+	if (promptChange) summaryParts.push("prompt changed");
+	if (modelChanges.length > 0) summaryParts.push(`${modelChanges.length} model changes`);
+	if (toolChanges.length > 0) summaryParts.push(`${toolChanges.length} tool changes`);
+	if (subAgentChanges.length > 0) summaryParts.push(`${subAgentChanges.length} sub-agent changes`);
+	if (summaryParts.length === 0) return `${fieldChanges.length} field changes`;
+	return summaryParts.join(", ");
+}
+/**
+* Generate summary for component addition/deletion
+*/
+function generateComponentSummary(componentType, changeType, component) {
+	const name = component?.name || component?.id || "unnamed";
+	const action = changeType === "added" ? "Added" : "Removed";
+	if (componentType === "tools") return `${action} ${component?.config?.type || "unknown type"} tool: ${name}`;
+	return `${action} ${componentType}: ${name}`;
+}
+/**
+* Generate summary for component modifications
+*/
+function generateComponentChangeSummary(componentType, fieldChanges) {
+	if (componentType === "tools") {
+		const configChanges = fieldChanges.filter((c) => c.field.startsWith("config"));
+		if (configChanges.length > 0) return `Configuration updated (${configChanges.length} changes)`;
+	}
+	return `${fieldChanges.length} field changes`;
+}
+/**
+* Deep equality check for component comparison with empty value equivalence
+*/
+function deepEqual(a, b) {
+	const aIsEmpty = isEmpty(a);
+	const bIsEmpty = isEmpty(b);
+	if (aIsEmpty && bIsEmpty) return true;
+	if (aIsEmpty !== bIsEmpty) return false;
+	return getDetailedFieldChanges("", a, b).length === 0;
+}
+/**
+* Extract status component IDs from agents
+*/
+function extractStatusComponentIds(project) {
+	const statusComponentIds = [];
+	if (!project.agents) return statusComponentIds;
+	for (const agentData of Object.values(project.agents)) if (agentData.statusUpdates?.statusComponents) for (const statusComp of agentData.statusUpdates.statusComponents) {
+		const statusCompId = statusComp.type || statusComp.id;
+		if (statusCompId && !statusComponentIds.includes(statusCompId)) statusComponentIds.push(statusCompId);
+	}
+	return statusComponentIds;
+}
+/**
+* Extract actual status component data from agents for comparison
+*/
+function extractStatusComponentsFromProject(project) {
+	const statusComponents = {};
+	if (!project.agents) return statusComponents;
+	for (const [_, agentData] of Object.entries(project.agents)) if (agentData.statusUpdates?.statusComponents) for (const statusComp of agentData.statusUpdates.statusComponents) {
+		const statusCompId = statusComp.type || statusComp.id;
+		if (statusCompId) statusComponents[statusCompId] = statusComp;
+	}
+	return statusComponents;
+}
+/**
+* Group changes by component type for easier processing
+*/
+function groupChangesByType(changes) {
+	const result = createEmptyComponentChanges();
+	changes.forEach((change) => {
+		const group = result[change.componentType];
+		if (group && !group[change.changeType].includes(change.componentId)) group[change.changeType].push(change.componentId);
+	});
+	return result;
+}
+/**
+* Create empty component changes structure
+*/
+function createEmptyComponentChanges() {
+	return {
+		agents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		subAgents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		tools: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		functionTools: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		functions: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		dataComponents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		artifactComponents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		statusComponents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		environments: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		contextConfigs: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		fetchDefinitions: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		headers: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		credentials: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		externalAgents: {
+			added: [],
+			modified: [],
+			deleted: []
+		},
+		models: {
+			added: [],
+			modified: [],
+			deleted: []
+		}
+	};
+}
+/**
+* Compare contextConfig components across agents
+*/
+function compareContextConfigs(localProject, remoteProject, localRegistry, debug) {
+	const changes = [];
+	new Set([...Object.keys(localProject.agents || {}), ...Object.keys(remoteProject.agents || {})]).forEach((agentId) => {
+		const localAgent = localProject.agents?.[agentId];
+		const remoteAgent = remoteProject.agents?.[agentId];
+		const localContextConfig = localAgent?.contextConfig;
+		const remoteContextConfig = remoteAgent?.contextConfig;
+		const contextId = localContextConfig?.id || remoteContextConfig?.id;
+		if (!contextId) return;
+		if (!localContextConfig && remoteContextConfig) changes.push({
+			componentType: "contextConfigs",
+			componentId: contextId,
+			changeType: "added",
+			summary: `Added contextConfig for agent: ${agentId}`
+		});
+		else if (localContextConfig && !remoteContextConfig) changes.push({
+			componentType: "contextConfigs",
+			componentId: contextId,
+			changeType: "deleted",
+			summary: `Removed contextConfig for agent: ${agentId}`
+		});
+		else if (localContextConfig && remoteContextConfig) {
+			const filteredChanges = getDetailedFieldChanges("", localContextConfig, remoteContextConfig).filter((change) => change.field !== "id");
+			if (filteredChanges.length > 0) changes.push({
+				componentType: "contextConfigs",
+				componentId: contextId,
+				changeType: "modified",
+				changedFields: filteredChanges,
+				summary: `Modified contextConfig for agent: ${agentId} (${filteredChanges.length} changes)`
+			});
+		}
+	});
+	return changes;
+}
+/**
+* Compare fetchDefinition components across contextConfigs
+*/
+function compareFetchDefinitions(localProject, remoteProject, debug) {
+	const changes = [];
+	const fetchDefinitions = /* @__PURE__ */ new Map();
+	const extractFetchDefinitions = (contextConfig) => {
+		const fetchDefs = [];
+		if (contextConfig && typeof contextConfig === "object" && contextConfig.contextVariables) Object.values(contextConfig.contextVariables).forEach((variable) => {
+			if (variable && typeof variable === "object" && variable.id && variable.fetchConfig) fetchDefs.push(variable);
+		});
+		return fetchDefs;
+	};
+	Object.entries(localProject.agents || {}).forEach(([agentId, agentData]) => {
+		if (agentData.contextConfig) extractFetchDefinitions(agentData.contextConfig).forEach((fetchDef) => {
+			if (!fetchDefinitions.has(fetchDef.id)) fetchDefinitions.set(fetchDef.id, {});
+			fetchDefinitions.get(fetchDef.id).local = fetchDef;
+		});
+	});
+	Object.entries(remoteProject.agents || {}).forEach(([agentId, agentData]) => {
+		if (agentData.contextConfig) extractFetchDefinitions(agentData.contextConfig).forEach((fetchDef) => {
+			if (!fetchDefinitions.has(fetchDef.id)) fetchDefinitions.set(fetchDef.id, {});
+			fetchDefinitions.get(fetchDef.id).remote = fetchDef;
+		});
+	});
+	fetchDefinitions.forEach((configs, fetchId) => {
+		const { local, remote } = configs;
+		if (!local && remote) changes.push({
+			componentType: "fetchDefinitions",
+			componentId: fetchId,
+			changeType: "added",
+			summary: `Added fetchDefinition: ${fetchId}`
+		});
+		else if (local && !remote) changes.push({
+			componentType: "fetchDefinitions",
+			componentId: fetchId,
+			changeType: "deleted",
+			summary: `Removed fetchDefinition: ${fetchId}`
+		});
+		else if (local && remote) {
+			if (!compareJsonObjects(local, remote, {
+				ignoreArrayOrder: true,
+				showDetails: true
+			}).isEqual) changes.push({
+				componentType: "fetchDefinitions",
+				componentId: fetchId,
+				changeType: "modified",
+				summary: `Modified fetchDefinition: ${fetchId}`
+			});
+		}
+	});
+	return changes;
+}
+/**
+* Normalize canDelegateTo array to handle enriched vs non-enriched forms
+* Converts both [{subAgentId: "id"}] and ["id"] to the same normalized form
+*/
+function normalizeCanDelegateTo(canDelegateTo) {
+	return canDelegateTo.map((item) => {
+		if (typeof item === "string") return item;
+		if (typeof item === "object" && item !== null) return item.subAgentId || item.agentId || item.externalAgentId || String(item);
+		return String(item);
+	});
+}
+
+//#endregion
+export { compareProjects };