@inkeep/agents-cli 0.39.4 → 0.40.0

package/dist/commands/pull-v3/component-updater.js

@@ -0,0 +1,710 @@
+import { generateAgentFile } from "./components/agent-generator.js";
+import { generateArtifactComponentFile } from "./components/artifact-component-generator.js";
+import { generateContextConfigFile } from "./components/context-config-generator.js";
+import { generateCredentialFile } from "./components/credential-generator.js";
+import { generateDataComponentFile } from "./components/data-component-generator.js";
+import { generateEnvironmentFile } from "./components/environment-generator.js";
+import { generateExternalAgentFile } from "./components/external-agent-generator.js";
+import { generateFunctionToolFile } from "./components/function-tool-generator.js";
+import { generateMcpToolFile } from "./components/mcp-tool-generator.js";
+import { generateProjectFile } from "./components/project-generator.js";
+import { generateStatusComponentFile } from "./components/status-component-generator.js";
+import { generateSubAgentFile } from "./components/sub-agent-generator.js";
+import { getAvailableModel } from "./utils/model-provider-detector.js";
+import { mergeComponentsWithLLM } from "./llm-content-merger.js";
+import { findSubAgentWithParent } from "./utils/component-registry.js";
+import "./project-validator.js";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import chalk from "chalk";
+import { spawn } from "node:child_process";
+import { generateText } from "ai";
+
+//#region src/commands/pull-v3/component-updater.ts
+/**
+* Component Updater - Update existing components with new data
+*/
+/**
+* Copy entire project to temp directory, including symlinks to parent files
+* that might be imported (e.g., ../../env.ts)
+*/
+function copyProjectToTemp(projectRoot, tempDirName) {
+	const tempDir = join(projectRoot, tempDirName);
+	function copyRecursively(sourceDir, targetDir) {
+		if (!existsSync(sourceDir)) return;
+		mkdirSync(targetDir, { recursive: true });
+		const entries = readdirSync(sourceDir);
+		for (const entry of entries) {
+			if (entry.startsWith(".temp-") || entry === "node_modules") continue;
+			const sourcePath = join(sourceDir, entry);
+			const targetPath = join(targetDir, entry);
+			const stat = statSync(sourcePath);
+			if (stat.isDirectory()) copyRecursively(sourcePath, targetPath);
+			else if (stat.isFile()) copyFileSync(sourcePath, targetPath);
+		}
+	}
+	copyRecursively(projectRoot, tempDir);
+	createParentSymlinks(projectRoot, tempDir);
+}
+/**
+* Create symlinks in the temp directory for parent files that might be imported
+* Scans project files for parent imports (../) and creates appropriate symlinks
+*/
+function createParentSymlinks(projectRoot, tempDir) {
+	const parentImports = findParentImports(tempDir);
+	for (const parentPath of parentImports) {
+		const sourcePath = resolve(projectRoot, parentPath);
+		if (!existsSync(sourcePath)) continue;
+		const targetPath = join(tempDir, parentPath);
+		if (existsSync(targetPath)) continue;
+		mkdirSync(dirname(targetPath), { recursive: true });
+		try {
+			symlinkSync(sourcePath, targetPath);
+		} catch {
+			try {
+				if (statSync(sourcePath).isFile()) copyFileSync(sourcePath, targetPath);
+			} catch {}
+		}
+	}
+}
+/**
+* Find all parent imports (../) in TypeScript files within a directory
+*/
+function findParentImports(dir) {
+	const parentImports = /* @__PURE__ */ new Set();
+	const importRegex = /(?:from\s+['"]|import\s+['"]|require\s*\(\s*['"])(\.\.[^'"]+)['"]/g;
+	function scanDir(currentDir) {
+		if (!existsSync(currentDir)) return;
+		try {
+			const entries = readdirSync(currentDir);
+			for (const entry of entries) {
+				if (entry === "node_modules" || entry.startsWith(".temp-")) continue;
+				const fullPath = join(currentDir, entry);
+				const stat = statSync(fullPath);
+				if (stat.isDirectory()) scanDir(fullPath);
+				else if (stat.isFile() && /\.[tj]sx?$/.test(entry)) {
+					const content = readFileSync(fullPath, "utf8");
+					let match;
+					while ((match = importRegex.exec(content)) !== null) {
+						const importPath = match[1];
+						const resolvedImport = join(relative(dir, dirname(fullPath)), importPath);
+						if (resolvedImport.startsWith("..")) {
+							parentImports.add(resolvedImport);
+							if (!resolvedImport.endsWith(".ts") && !resolvedImport.endsWith(".js")) parentImports.add(resolvedImport + ".ts");
+						}
+					}
+				}
+			}
+		} catch {}
+	}
+	scanDir(dir);
+	return Array.from(parentImports);
+}
+/**
+* Check for stale components and prompt user for cleanup permission
+*/
+async function checkAndPromptForStaleComponentCleanup(projectRoot, remoteProject, localRegistry) {
+	const remoteComponentIds = /* @__PURE__ */ new Set();
+	if (remoteProject.agents) Object.keys(remoteProject.agents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.tools) Object.keys(remoteProject.tools).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.functionTools) Object.keys(remoteProject.functionTools).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.functions) Object.keys(remoteProject.functions).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.dataComponents) Object.keys(remoteProject.dataComponents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.artifactComponents) Object.keys(remoteProject.artifactComponents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.credentialReferences) Object.keys(remoteProject.credentialReferences).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.externalAgents) Object.keys(remoteProject.externalAgents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.environments) Object.keys(remoteProject.environments).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.headers) Object.keys(remoteProject.headers).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.models) remoteComponentIds.add("project");
+	if (remoteProject.name || remoteProject.description) remoteComponentIds.add(remoteProject.name || "project");
+	if (remoteProject.agents) Object.values(remoteProject.agents).forEach((agent) => {
+		if (agent.subAgents) {
+			Object.keys(agent.subAgents).forEach((id) => remoteComponentIds.add(id));
+			Object.values(agent.subAgents).forEach((subAgent) => {
+				if (subAgent.functionTools) Object.keys(subAgent.functionTools).forEach((id) => remoteComponentIds.add(id));
+				if (subAgent.tools) Object.keys(subAgent.tools).forEach((id) => remoteComponentIds.add(id));
+			});
+		}
+		if (agent.contextConfig && agent.contextConfig.id) {
+			remoteComponentIds.add(agent.contextConfig.id);
+			if (agent.contextConfig.contextVariables) Object.values(agent.contextConfig.contextVariables).forEach((variable) => {
+				if (variable && typeof variable === "object" && variable.id) remoteComponentIds.add(variable.id);
+			});
+			if (agent.contextConfig.headers) Object.keys(agent.contextConfig.headers).forEach((id) => remoteComponentIds.add(id));
+		}
+		if (agent.statusUpdates?.statusComponents) agent.statusUpdates.statusComponents.forEach((statusComp) => {
+			const statusCompId = statusComp.type || statusComp.id;
+			if (statusCompId) remoteComponentIds.add(statusCompId);
+		});
+		if (agent.models) remoteComponentIds.add(`${agent.id || "unknown"}-models`);
+	});
+	const staleComponents = [];
+	for (const component of localRegistry.getAllComponents()) {
+		if (component.type === "project") continue;
+		if (!remoteComponentIds.has(component.id)) staleComponents.push(component);
+	}
+	if (staleComponents.length === 0) return false;
+	console.log(chalk.yellow(`\n🧹 Found ${staleComponents.length} stale component(s) that don't exist in remote project:`));
+	staleComponents.forEach((comp) => {
+		const typeLabel = comp.type.replace(/s$/, "").replace(/^./, (c) => c.toUpperCase());
+		console.log(chalk.gray(`   • ${typeLabel}: ${chalk.cyan(comp.id)}`));
+		console.log(chalk.gray(`     └─ File: ${comp.filePath}`));
+	});
+	console.log(chalk.cyan(`\n❓ Would you like to remove these stale components from your project?`));
+	console.log(chalk.green(`   [Y] Yes - Clean up stale components`));
+	console.log(chalk.red(`   [N] No - Keep existing components`));
+	return new Promise((resolve$1) => {
+		process.stdin.removeAllListeners("data");
+		process.stdin.removeAllListeners("keypress");
+		process.stdin.removeAllListeners("end");
+		if (process.stdin.isTTY) process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdin.setEncoding("utf8");
+		const onKeypress = (key) => {
+			process.stdin.removeAllListeners("data");
+			process.stdin.removeAllListeners("keypress");
+			process.stdin.removeAllListeners("end");
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			process.stdin.pause();
+			const normalizedKey = key.toLowerCase();
+			if (normalizedKey === "y") {
+				console.log(chalk.green(`\n✅ Selected: Yes - Will clean up stale components`));
+				resolve$1(true);
+			} else if (normalizedKey === "n") {
+				console.log(chalk.yellow(`\n❌ Selected: No - Keeping existing components`));
+				resolve$1(false);
+			} else {
+				console.log(chalk.red(`\n❌ Invalid key: "${key}". Skipping cleanup.`));
+				resolve$1(false);
+			}
+		};
+		process.stdin.once("data", onKeypress);
+		process.stdout.write(chalk.cyan("\nPress [Y] for Yes or [N] for No: "));
+	});
+}
+/**
+* Clean up stale components that don't exist in remote project
+* @param projectRoot - Root project directory
+* @param tempDirName - Temp directory name (empty string = operate on original project)
+* @param remoteProject - Remote project definition
+* @param localRegistry - Local component registry
+*/
+async function cleanupStaleComponents(projectRoot, tempDirName, remoteProject, localRegistry) {
+	const tempDir = join(projectRoot, tempDirName);
+	const remoteComponentIds = /* @__PURE__ */ new Set();
+	if (remoteProject.agents) Object.keys(remoteProject.agents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.tools) Object.keys(remoteProject.tools).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.functionTools) Object.keys(remoteProject.functionTools).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.functions) Object.keys(remoteProject.functions).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.dataComponents) Object.keys(remoteProject.dataComponents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.artifactComponents) Object.keys(remoteProject.artifactComponents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.credentialReferences) Object.keys(remoteProject.credentialReferences).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.externalAgents) Object.keys(remoteProject.externalAgents).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.environments) Object.keys(remoteProject.environments).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.headers) Object.keys(remoteProject.headers).forEach((id) => remoteComponentIds.add(id));
+	if (remoteProject.models) remoteComponentIds.add("project");
+	if (remoteProject.name || remoteProject.description) remoteComponentIds.add(remoteProject.name || "project");
+	if (remoteProject.agents) Object.values(remoteProject.agents).forEach((agent) => {
+		if (agent.subAgents) {
+			Object.keys(agent.subAgents).forEach((id) => remoteComponentIds.add(id));
+			Object.values(agent.subAgents).forEach((subAgent) => {
+				if (subAgent.functionTools) Object.keys(subAgent.functionTools).forEach((id) => remoteComponentIds.add(id));
+				if (subAgent.tools) Object.keys(subAgent.tools).forEach((id) => remoteComponentIds.add(id));
+			});
+		}
+		if (agent.contextConfig && agent.contextConfig.id) {
+			remoteComponentIds.add(agent.contextConfig.id);
+			if (agent.contextConfig.contextVariables) Object.values(agent.contextConfig.contextVariables).forEach((variable) => {
+				if (variable && typeof variable === "object" && variable.id) remoteComponentIds.add(variable.id);
+			});
+			if (agent.contextConfig.headers) Object.keys(agent.contextConfig.headers).forEach((id) => remoteComponentIds.add(id));
+		}
+		if (agent.statusUpdates?.statusComponents) agent.statusUpdates.statusComponents.forEach((statusComp) => {
+			const statusCompId = statusComp.type || statusComp.id;
+			if (statusCompId) remoteComponentIds.add(statusCompId);
+		});
+		if (agent.models) remoteComponentIds.add(`${agent.id || "unknown"}-models`);
+	});
+	localRegistry.getAllComponents();
+	const staleComponents = [];
+	for (const component of localRegistry.getAllComponents()) {
+		if (component.type === "project") continue;
+		if (!remoteComponentIds.has(component.id)) staleComponents.push(component);
+	}
+	if (staleComponents.length === 0) return;
+	const staleComponentsByFile = /* @__PURE__ */ new Map();
+	for (const component of staleComponents) {
+		const filePath = component.filePath;
+		if (!staleComponentsByFile.has(filePath)) staleComponentsByFile.set(filePath, []);
+		staleComponentsByFile.get(filePath).push(component);
+	}
+	for (const [originalFilePath, staleComponentsInFile] of staleComponentsByFile) {
+		const tempFilePath = join(tempDir, originalFilePath.replace(projectRoot + "/", ""));
+		if (!existsSync(tempFilePath)) continue;
+		if (localRegistry.getComponentsInFile(originalFilePath).filter((component) => !staleComponentsInFile.some((stale) => stale.id === component.id)).length === 0) unlinkSync(tempFilePath);
+		else {
+			const currentContent = readFileSync(tempFilePath, "utf8");
+			const cleanedContent = await removeComponentsFromFile(currentContent, staleComponentsInFile.map((c) => ({
+				id: c.id,
+				type: c.type
+			})), tempFilePath);
+			if (cleanedContent !== currentContent) writeFileSync(tempFilePath, cleanedContent, "utf8");
+		}
+	}
+	for (const staleComponent of staleComponents) localRegistry.removeComponent(staleComponent.type, staleComponent.id);
+}
+/**
+* Use LLM specifically for component removal with custom prompt
+*/
+async function removeComponentsWithLLM(fileContent, prompt) {
+	try {
+		let cleanedResponse = (await generateText({
+			model: await getAvailableModel(),
+			prompt: prompt + "\n\nFile content:\n```typescript\n" + fileContent + "\n```"
+		})).text.replace(/^```(?:typescript|ts|javascript|js)?\s*\n?/i, "");
+		cleanedResponse = cleanedResponse.replace(/\n?```\s*$/i, "");
+		return cleanedResponse.trim();
+	} catch (error) {
+		console.error("LLM removal failed:", error);
+		return fileContent;
+	}
+}
+/**
+* Use LLM to remove specific components from file content
+*/
+async function removeComponentsFromFile(fileContent, componentsToRemove, filePath) {
+	const prompt = `Remove the following components from this TypeScript file: ${componentsToRemove.map((c) => `${c.type}:${c.id}`).join(", ")}
+
+Please remove these components completely, including:
+- Their export statements
+- Their variable declarations/definitions  
+- Any imports that are no longer needed after removal
+- Any related helper code specific to these components
+
+Keep all other components, imports, and code that are still needed. Ensure the file remains syntactically valid TypeScript.
+
+Original file content:
+${fileContent}
+
+Return only the cleaned TypeScript code with the specified components removed.`;
+	try {
+		return await removeComponentsWithLLM(fileContent, prompt);
+	} catch (error) {
+		return fileContent;
+	}
+}
+/**
+* Write content to temp directory (overwrite if exists)
+*/
+function writeToTempDirectory(projectRoot, filePath, content, tempDirName) {
+	const tempFilePath = join(join(projectRoot, tempDirName), filePath.replace(projectRoot + "/", ""));
+	mkdirSync(dirname(tempFilePath), { recursive: true });
+	writeFileSync(tempFilePath, content, "utf8");
+}
+/**
+* Run Biome formatter and linter on a file
+*/
+async function runBiomeOnFile(filePath) {
+	try {
+		const ext = extname(filePath);
+		if (![
+			".ts",
+			".js",
+			".tsx",
+			".jsx"
+		].includes(ext)) return true;
+		await new Promise((resolve$1, reject) => {
+			const formatProcess = spawn("npx", [
+				"biome",
+				"format",
+				"--write",
+				filePath
+			], { stdio: "pipe" });
+			formatProcess.on("close", (code) => {
+				if (code === 0) resolve$1();
+				else reject(/* @__PURE__ */ new Error(`Biome format exited with code ${code}`));
+			});
+			formatProcess.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to run biome format: ${err.message}`));
+			});
+		});
+		await new Promise((resolve$1, reject) => {
+			const lintProcess = spawn("npx", [
+				"biome",
+				"lint",
+				"--write",
+				filePath
+			], { stdio: "pipe" });
+			lintProcess.on("close", (code) => {
+				if (code === 0) resolve$1();
+				else reject(/* @__PURE__ */ new Error(`Biome lint exited with code ${code}`));
+			});
+			lintProcess.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to run biome lint: ${err.message}`));
+			});
+		});
+		return true;
+	} catch (error) {
+		error instanceof Error && error.message;
+		return false;
+	}
+}
+/**
+* Run Biome formatter and linter on an entire directory
+*/
+async function runBiomeOnDirectory(dirPath) {
+	try {
+		await new Promise((resolve$1, reject) => {
+			const formatProcess = spawn("npx", [
+				"biome",
+				"format",
+				"--write",
+				"."
+			], {
+				cwd: dirPath,
+				stdio: "pipe"
+			});
+			formatProcess.on("close", (code) => {
+				if (code === 0) resolve$1();
+				else reject(/* @__PURE__ */ new Error(`Biome format exited with code ${code}`));
+			});
+			formatProcess.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to run biome format: ${err.message}`));
+			});
+		});
+		await new Promise((resolve$1, reject) => {
+			const lintProcess = spawn("npx", [
+				"biome",
+				"lint",
+				"--write",
+				"."
+			], {
+				cwd: dirPath,
+				stdio: "pipe"
+			});
+			lintProcess.on("close", (code) => {
+				if (code === 0) resolve$1();
+				else reject(/* @__PURE__ */ new Error(`Biome lint exited with code ${code}`));
+			});
+			lintProcess.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to run biome lint: ${err.message}`));
+			});
+		});
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+/**
+* Generate updated component content using appropriate generator
+*/
+function generateUpdatedComponentContent(componentType, componentId, componentData, remoteProject, localRegistry, environment, actualFilePath) {
+	const defaultStyle = {
+		quotes: "single",
+		indentation: "  ",
+		semicolons: true
+	};
+	switch (componentType) {
+		case "agents": {
+			const contextConfigData = componentData.contextConfig;
+			const projectModels = remoteProject.models;
+			return generateAgentFile(componentId, componentData, defaultStyle, localRegistry, contextConfigData, projectModels, actualFilePath);
+		}
+		case "subAgents": {
+			const parentInfo = findSubAgentWithParent(remoteProject, componentId);
+			const parentAgentId = parentInfo?.parentAgentId;
+			const contextConfigData = parentInfo?.contextConfigData;
+			return generateSubAgentFile(componentId, componentData, defaultStyle, localRegistry, parentAgentId, contextConfigData, parentInfo ? remoteProject.agents?.[parentInfo.parentAgentId]?.models : void 0, actualFilePath);
+		}
+		case "tools": return generateMcpToolFile(componentId, componentData, defaultStyle, localRegistry);
+		case "functionTools":
+		case "functions": return generateFunctionToolFile(componentId, componentData, defaultStyle);
+		case "dataComponents": return generateDataComponentFile(componentId, componentData, defaultStyle);
+		case "artifactComponents": return generateArtifactComponentFile(componentId, componentData, defaultStyle);
+		case "statusComponents": return generateStatusComponentFile(componentId, componentData, defaultStyle);
+		case "environments": return generateEnvironmentFile(componentId, componentData, defaultStyle, localRegistry);
+		case "externalAgents": return generateExternalAgentFile(componentId, componentData, defaultStyle, localRegistry);
+		case "credentials": return generateCredentialFile(componentId, componentData, defaultStyle);
+		case "contextConfigs": {
+			const agentId = componentData._agentId;
+			const cleanComponentData = { ...componentData };
+			delete cleanComponentData._agentId;
+			return generateContextConfigFile(componentId, cleanComponentData, defaultStyle, localRegistry, agentId);
+		}
+		case "fetchDefinitions": return "";
+		case "projects": return generateProjectFile(componentId, componentData, defaultStyle, localRegistry);
+		default: throw new Error(`No generator for component type: ${componentType}`);
+	}
+}
+/**
+* Update existing components that have been modified
+*/
+async function updateModifiedComponents(comparison, remoteProject, localRegistry, projectRoot, environment, debug = false, providedTempDirName, newComponents) {
+	const results = [];
+	const tempDirName = providedTempDirName || `.temp-${Date.now()}`;
+	if (!providedTempDirName) {
+		console.log(chalk.cyan(`📁 Copying project to ${tempDirName}...`));
+		copyProjectToTemp(projectRoot, tempDirName);
+		console.log(chalk.green(`✅ Project copied to temp directory`));
+	}
+	const allModifiedComponents = [];
+	for (const [componentType, changes] of Object.entries(comparison.componentChanges)) for (const componentId of changes.modified) allModifiedComponents.push({
+		type: componentType,
+		id: componentId
+	});
+	if (allModifiedComponents.length === 0) return results;
+	const componentsByFile = /* @__PURE__ */ new Map();
+	for (const { type: componentType, id: componentId } of allModifiedComponents) {
+		let actualComponentType = componentType;
+		if (componentType === "functions") actualComponentType = "functionTools";
+		const localComponent = localRegistry.get(componentId, actualComponentType);
+		const singularType = actualComponentType.slice(0, -1);
+		const localComponentSingular = localRegistry.get(componentId, singularType);
+		const actualComponent = localComponent || localComponentSingular;
+		if (actualComponent) {
+			const filePath = actualComponent.filePath.startsWith("/") ? actualComponent.filePath : `${projectRoot}/${actualComponent.filePath}`;
+			if (!componentsByFile.has(filePath)) componentsByFile.set(filePath, []);
+			componentsByFile.get(filePath).push({
+				type: componentType,
+				id: componentId,
+				registryInfo: actualComponent
+			});
+		}
+	}
+	console.log(chalk.cyan(`\n🔄 Updating ${componentsByFile.size} files with modified components...`));
+	let fileIndex = 0;
+	const totalFiles = componentsByFile.size;
+	for (const [filePath, fileComponents] of componentsByFile) {
+		fileIndex++;
+		try {
+			const relativeFilePath = filePath.replace(projectRoot + "/", "");
+			const componentNames = fileComponents.map((c) => `${c.type}:${c.id}`).join(", ");
+			console.log(chalk.gray(`   [${fileIndex}/${totalFiles}] Processing: ${relativeFilePath}`));
+			console.log(chalk.gray(`            Components: ${componentNames}`));
+			const oldContent = readFileSync(filePath, "utf8");
+			const componentContentParts = [];
+			const componentResults = [];
+			for (const { type: componentType, id: componentId } of fileComponents) {
+				let componentData = null;
+				if (componentType === "contextConfigs") {
+					for (const [agentId, agentData] of Object.entries(remoteProject.agents || {})) if (agentData.contextConfig && agentData.contextConfig.id === componentId) {
+						componentData = agentData.contextConfig;
+						componentData._agentId = agentId;
+						break;
+					}
+				} else if (componentType === "fetchDefinitions") for (const [agentId, agentData] of Object.entries(remoteProject.agents || {})) {
+					const contextConfig = agentData.contextConfig;
+					if (contextConfig && contextConfig.contextVariables) {
+						for (const [varName, variable] of Object.entries(contextConfig.contextVariables)) if (variable?.id === componentId) {
+							componentData = variable;
+							break;
+						}
+						if (componentData) break;
+					}
+				}
+				else if (componentType === "subAgents") {
+					for (const [agentId, agentData] of Object.entries(remoteProject.agents || {})) if (agentData.subAgents && agentData.subAgents[componentId]) {
+						componentData = agentData.subAgents[componentId];
+						break;
+					}
+				} else if (componentType === "statusComponents") {
+					for (const [agentId, agentData] of Object.entries(remoteProject.agents || {})) if (agentData.statusUpdates?.statusComponents && agentData.statusUpdates.statusComponents) {
+						for (const statusComp of agentData.statusUpdates.statusComponents) if (statusComp["type"] === componentId) {
+							componentData = statusComp;
+							break;
+						}
+					}
+				} else if (componentType === "credentials") componentData = remoteProject.credentialReferences?.[componentId];
+				else if (componentType === "environments") componentData = {
+					name: `${componentId} Environment`,
+					description: `Environment configuration for ${componentId}`,
+					credentials: remoteProject.credentialReferences || {}
+				};
+				else {
+					componentData = (remoteProject[componentType] || {})[componentId];
+					if (componentType === "agents" && componentData && !componentData.credentials && remoteProject.credentialReferences) {
+						const agentCredentials = [];
+						const credentialSet = /* @__PURE__ */ new Set();
+						if (componentData.contextConfig?.contextVariables) {
+							for (const [varName, varData] of Object.entries(componentData.contextConfig.contextVariables)) if (varData && typeof varData === "object" && varData.credentialReferenceId) {
+								const credId = varData.credentialReferenceId;
+								if (remoteProject.credentialReferences[credId] && !credentialSet.has(credId)) {
+									credentialSet.add(credId);
+									agentCredentials.push({ id: credId });
+								}
+							}
+						}
+						for (const [credId, credData] of Object.entries(remoteProject.credentialReferences)) if (credData.usedBy) {
+							for (const usage of credData.usedBy) if (usage.type === "agent" && usage.id === componentId && !credentialSet.has(credId)) {
+								credentialSet.add(credId);
+								agentCredentials.push({ id: credId });
+								break;
+							}
+						}
+						if (agentCredentials.length > 0) componentData.credentials = agentCredentials;
+					}
+				}
+				if (!componentData) {
+					componentResults.push({
+						componentId,
+						componentType,
+						success: false,
+						error: `Component data not found in remote project.${componentType}`
+					});
+					continue;
+				}
+				try {
+					const componentContent = generateUpdatedComponentContent(componentType, componentId, componentData, remoteProject, localRegistry, environment, relativeFilePath);
+					componentContentParts.push(`// ${componentType}:${componentId}\n${componentContent}`);
+					componentResults.push({
+						componentId,
+						componentType,
+						success: true
+					});
+				} catch (error) {
+					const errorMsg = error instanceof Error ? error.message : String(error);
+					componentResults.push({
+						componentId,
+						componentType,
+						success: false,
+						error: errorMsg
+					});
+				}
+			}
+			const failedComponents = componentResults.filter((r) => !r.success);
+			if (failedComponents.length > 0) {
+				failedComponents.forEach((comp) => {
+					results.push({
+						componentId: comp.componentId,
+						componentType: comp.componentType,
+						filePath,
+						success: false,
+						error: comp.error
+					});
+				});
+				if (failedComponents.length === componentResults.length) continue;
+			}
+			const newComponentContent = componentContentParts.join("\n\n");
+			let componentsToExport = [];
+			try {
+				componentsToExport = analyzeComponentsToExport(newComponents || [], relativeFilePath, localRegistry);
+			} catch (error) {}
+			const mergeResult = await mergeComponentsWithLLM({
+				oldContent,
+				newContent: newComponentContent,
+				modifiedComponents: fileComponents.map((c) => ({
+					componentId: c.id,
+					componentType: c.type
+				})),
+				filePath,
+				newComponents,
+				componentsToExport
+			});
+			let finalContent;
+			if (!mergeResult.success) finalContent = newComponentContent;
+			else finalContent = mergeResult.mergedContent;
+			writeToTempDirectory(projectRoot, filePath, finalContent, tempDirName);
+			const relativePath = filePath.replace(projectRoot + "/", "");
+			const tempFilePath = join(projectRoot, tempDirName, relativePath);
+			if (await runBiomeOnFile(tempFilePath)) {
+				const formattedContent = readFileSync(tempFilePath, "utf8");
+				console.log(chalk.green(`   ✅ File formatted and written: ${tempDirName}/${relativePath} (${formattedContent.length} chars)`));
+			} else console.log(chalk.cyan(`   💾 Final content written to ${tempDirName}/${relativePath} (${finalContent.length} chars)`));
+			if (oldContent.trim() === finalContent.trim()) {
+				fileComponents.forEach((comp) => {
+					results.push({
+						componentId: comp.id,
+						componentType: comp.type,
+						filePath,
+						success: true,
+						oldContent,
+						newContent: finalContent
+					});
+				});
+				continue;
+			}
+			fileComponents.forEach((comp) => {
+				results.push({
+					componentId: comp.id,
+					componentType: comp.type,
+					filePath,
+					success: true,
+					oldContent,
+					newContent: newComponentContent
+				});
+			});
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			fileComponents.forEach((comp) => {
+				results.push({
+					componentId: comp.id,
+					componentType: comp.type,
+					filePath,
+					success: false,
+					error: errorMsg
+				});
+			});
+		}
+	}
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	const actualChanges = successful.filter((r) => r.oldContent?.trim() !== r.newContent?.trim());
+	console.log(chalk.yellow(`\n📋 Analyzed ${actualChanges.length} components with changes`));
+	if (actualChanges.length > 0) actualChanges.forEach((change) => {
+		console.log(chalk.blue(`   🔄 ${change.componentType}:${change.componentId} in ${change.filePath}`));
+		if (debug) {
+			console.log(chalk.gray(`      🔍 Available comparison changes: ${comparison.changes.length}`));
+			comparison.changes.forEach((c, i) => {
+				console.log(chalk.gray(`        ${i}: ${c.componentType}:${c.componentId} (${c.changeType})`));
+			});
+		}
+		const normalizedCompType = change.componentType.endsWith("s") && change.componentType !== "headers" ? change.componentType.slice(0, -1) : change.componentType;
+		const componentChanges = comparison.changes.filter((c) => c.componentId === change.componentId && c.componentType === normalizedCompType);
+		if (debug) console.log(chalk.gray(`      🔍 Matching changes found: ${componentChanges.length}`));
+		componentChanges.forEach((compChange) => {
+			if (compChange.changedFields && compChange.changedFields.length > 0) compChange.changedFields.forEach((fieldChange) => {
+				const changeSymbol = fieldChange.changeType === "added" ? "➕" : fieldChange.changeType === "deleted" ? "➖" : "🔄";
+				console.log(chalk.gray(`      ${changeSymbol} ${fieldChange.field}: ${fieldChange.description || fieldChange.changeType}`));
+			});
+			else if (debug) console.log(chalk.gray(`      🔍 No changedFields data available for this change`));
+			if (compChange.summary) console.log(chalk.gray(`      📝 ${compChange.summary}`));
+		});
+	});
+	if (successful.length > actualChanges.length) console.log(chalk.gray(`   ⚪ ${successful.length - actualChanges.length} components had no changes`));
+	if (failed.length > 0) console.log(chalk.red(`   ❌ ${failed.length} components failed to analyze`));
+	await runBiomeOnDirectory(join(projectRoot, tempDirName));
+	return results;
+}
+/**
+* Analyze which existing components need to be exported because they're referenced by new components
+*/
+function analyzeComponentsToExport(newComponents, currentFilePath, localRegistry) {
+	const componentsToExport = [];
+	for (const newComp of newComponents) {
+		if (newComp.filePath === currentFilePath) continue;
+		const allLocalComponents = localRegistry.getAllComponents();
+		for (const localComp of allLocalComponents) if ((localComp.filePath.startsWith("/") ? localComp.filePath.split("/").slice(-2).join("/") : localComp.filePath) === currentFilePath) {
+			if (shouldComponentBeExported(localComp, newComponents)) {
+				if (!componentsToExport.find((c) => c.componentId === localComp.id)) componentsToExport.push({
+					componentId: localComp.id,
+					variableName: localComp.name,
+					reason: `referenced by new component ${newComp.componentType}:${newComp.componentId}`
+				});
+			}
+		}
+	}
+	return componentsToExport;
+}
+/**
+* Determine if a component should be exported based on heuristics
+*/
+function shouldComponentBeExported(localComponent, newComponents) {
+	if (localComponent.type === "agents" || localComponent.type === "subAgents") return true;
+	if (localComponent.type === "tools" || localComponent.type === "functionTools") return true;
+	if (localComponent.type === "contextConfigs") return true;
+	if (localComponent.type === "artifactComponents") return true;
+	return false;
+}
+
+//#endregion
+export { checkAndPromptForStaleComponentCleanup, cleanupStaleComponents, copyProjectToTemp, updateModifiedComponents };