@inkeep/agents-cli 0.50.6 → 0.52.0

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

@@ -1,768 +0,0 @@
-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 { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
-import { 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(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?.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?.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 allLocalComponents = localRegistry.getAllComponents();
-	const staleComponents = [];
-	for (const component of allLocalComponents) {
-		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
-			})));
-			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}
-
-File content:
-\`\`\`typescript
-${fileContent}
-\`\`\``
-		})).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) {
-	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 {
-		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 {
-		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 {
-		return false;
-	}
-}
-/**
-* Generate updated component content using appropriate generator
-*/
-function generateUpdatedComponentContent(componentType, componentId, componentData, remoteProject, localRegistry, 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 cleanComponentData = { ...componentData };
-			delete cleanComponentData._agentId;
-			return generateContextConfigFile(componentId, cleanComponentData, defaultStyle, localRegistry);
-		}
-		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, 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 agentData of Object.values(remoteProject.agents || {})) {
-					const contextConfig = agentData.contextConfig;
-					if (contextConfig?.contextVariables) {
-						for (const variable of Object.values(contextConfig.contextVariables)) if (variable?.id === componentId) {
-							componentData = variable;
-							break;
-						}
-						if (componentData) break;
-					}
-				}
-				else if (componentType === "subAgents") {
-					for (const agentData of Object.values(remoteProject.agents || {})) if (agentData.subAgents?.[componentId]) {
-						componentData = agentData.subAgents[componentId];
-						break;
-					}
-				} else if (componentType === "statusComponents") {
-					for (const agentData of Object.values(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 varData of Object.values(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, 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 {}
-			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)) {
-				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) {
-	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 };