@inkeep/agents-cli 0.39.5 → 0.41.0

package/dist/commands/pull-v3/introspect-generator.js

@@ -0,0 +1,278 @@
+import { DEFAULT_STYLE } from "./utils/generator-utils.js";
+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, generateEnvironmentIndexFile } 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 { ComponentRegistry, registerAllComponents } from "./utils/component-registry.js";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import chalk from "chalk";
+
+//#region src/commands/pull-v3/introspect-generator.ts
+/**
+* Introspect Generator - Complete project regeneration
+*
+* This module handles the --introspect mode which regenerates all files
+* from scratch without any comparison or diffing logic.
+*/
+/**
+* Helper function to ensure directory exists
+*/
+function ensureDir(filePath) {
+	mkdirSync(dirname(filePath), { recursive: true });
+}
+/**
+* Check if an agent is complete enough for code generation
+* An agent needs a name, defaultSubAgentId, and at least one sub-agent
+*/
+function isAgentComplete(agentId, agentData) {
+	if (!agentData.name) return {
+		complete: false,
+		reason: "missing name"
+	};
+	if (!agentData.defaultSubAgentId) return {
+		complete: false,
+		reason: "missing defaultSubAgentId (no sub-agents configured)"
+	};
+	if (!agentData.subAgents || Object.keys(agentData.subAgents).length === 0) return {
+		complete: false,
+		reason: "no sub-agents defined"
+	};
+	return { complete: true };
+}
+/**
+* Generate all files from scratch using deterministic generation
+*/
+async function introspectGenerate(project, paths, environment, debug, options = {}) {
+	if (debug) console.log(chalk.gray("🔍 Regenerating all project files..."));
+	const generatedFiles = [];
+	const style = {
+		...DEFAULT_STYLE,
+		...options.codeStyle
+	};
+	const skippedAgents = [];
+	const registry = new ComponentRegistry();
+	try {
+		registerAllComponents(project, registry);
+		if (project.credentialReferences) for (const [credId, credData] of Object.entries(project.credentialReferences)) {
+			const credentialFile = join(paths.credentialsDir, `${credId}.ts`);
+			const credentialContent = generateCredentialFile(credId, credData, style);
+			ensureDir(credentialFile);
+			writeFileSync(credentialFile, credentialContent, "utf-8");
+			generatedFiles.push(credentialFile);
+		}
+		const envFile = join(paths.environmentsDir, `${environment}.env.ts`);
+		const envContent = generateEnvironmentFile(environment, {
+			name: `${environment} Environment`,
+			description: `Environment configuration for ${environment}`,
+			credentials: project.credentialReferences ? Object.keys(project.credentialReferences) : []
+		}, style, registry);
+		ensureDir(envFile);
+		writeFileSync(envFile, envContent, "utf-8");
+		generatedFiles.push(envFile);
+		const envIndexFile = join(paths.environmentsDir, "index.ts");
+		const envIndexContent = generateEnvironmentIndexFile([environment], style);
+		ensureDir(envIndexFile);
+		writeFileSync(envIndexFile, envIndexContent, "utf-8");
+		generatedFiles.push(envIndexFile);
+		const functionToolsGenerated = /* @__PURE__ */ new Set();
+		if (project.functionTools) for (const [toolId, toolData] of Object.entries(project.functionTools)) {
+			const functionId = toolData.functionId;
+			const funcData = functionId ? project.functions?.[functionId] : void 0;
+			const mergedData = {
+				name: toolData.name,
+				description: toolData.description,
+				inputSchema: funcData?.inputSchema,
+				executeCode: funcData?.executeCode,
+				execute: funcData?.executeCode,
+				dependencies: funcData?.dependencies
+			};
+			const functionFile = join(paths.toolsDir, "functions", `${toolId}.ts`);
+			const functionContent = generateFunctionToolFile(toolId, mergedData, style);
+			ensureDir(functionFile);
+			writeFileSync(functionFile, functionContent, "utf-8");
+			generatedFiles.push(functionFile);
+			functionToolsGenerated.add(toolId);
+		}
+		if (project.agents) for (const [agentId, agentData] of Object.entries(project.agents)) {
+			const agentFunctionTools = agentData.functionTools;
+			const agentFunctions = agentData.functions;
+			if (agentFunctionTools) for (const [toolId, toolData] of Object.entries(agentFunctionTools)) {
+				if (functionToolsGenerated.has(toolId)) continue;
+				const functionId = toolData.functionId;
+				const funcData = functionId ? agentFunctions?.[functionId] || project.functions?.[functionId] : void 0;
+				const mergedData = {
+					name: toolData.name,
+					description: toolData.description,
+					inputSchema: funcData?.inputSchema,
+					executeCode: funcData?.executeCode,
+					execute: funcData?.executeCode,
+					dependencies: funcData?.dependencies
+				};
+				const functionFile = join(paths.toolsDir, "functions", `${toolId}.ts`);
+				const functionContent = generateFunctionToolFile(toolId, mergedData, style);
+				ensureDir(functionFile);
+				writeFileSync(functionFile, functionContent, "utf-8");
+				generatedFiles.push(functionFile);
+				functionToolsGenerated.add(toolId);
+			}
+		}
+		if (project.functions) {
+			for (const [funcId, funcData] of Object.entries(project.functions)) if (!functionToolsGenerated.has(funcId)) {
+				if (!(Object.values(project.functionTools || {}).some((ft) => ft.functionId === funcId) || Object.values(project.agents || {}).some((agent) => Object.values(agent.functionTools || {}).some((ft) => ft.functionId === funcId))) && debug) console.log(chalk.yellow(`⚠️  Skipping orphaned function '${funcId}' - no functionTool references it`));
+			}
+		}
+		if (project.tools) for (const [toolId, toolData] of Object.entries(project.tools)) {
+			const toolFile = join(paths.toolsDir, `${toolId}.ts`);
+			const toolContent = generateMcpToolFile(toolId, toolData, style, registry);
+			ensureDir(toolFile);
+			writeFileSync(toolFile, toolContent, "utf-8");
+			generatedFiles.push(toolFile);
+		}
+		if (project.dataComponents) for (const [dataId, dataData] of Object.entries(project.dataComponents)) {
+			const dataFile = join(paths.dataComponentsDir, `${dataId}.ts`);
+			const dataContent = generateDataComponentFile(dataId, dataData, style);
+			ensureDir(dataFile);
+			writeFileSync(dataFile, dataContent, "utf-8");
+			generatedFiles.push(dataFile);
+		}
+		if (project.artifactComponents) for (const [artifactId, artifactData] of Object.entries(project.artifactComponents)) {
+			const artifactFile = join(paths.artifactComponentsDir, `${artifactId}.ts`);
+			const artifactContent = generateArtifactComponentFile(artifactId, artifactData, style);
+			ensureDir(artifactFile);
+			writeFileSync(artifactFile, artifactContent, "utf-8");
+			generatedFiles.push(artifactFile);
+		}
+		const registeredStatusComponents = registry.getAllComponents().filter((c) => c.type === "statusComponents");
+		if (registeredStatusComponents.length > 0) for (const statusComp of registeredStatusComponents) {
+			const statusData = findStatusComponentData(project, statusComp.id);
+			if (statusData) {
+				const statusFile = join(paths.statusComponentsDir, `${statusComp.id}.ts`);
+				const statusContent = generateStatusComponentFile(statusComp.id, statusData, style);
+				ensureDir(statusFile);
+				writeFileSync(statusFile, statusContent, "utf-8");
+				generatedFiles.push(statusFile);
+			}
+		}
+		if (project.externalAgents) for (const [extAgentId, extAgentData] of Object.entries(project.externalAgents)) {
+			const extAgentFile = join(paths.externalAgentsDir, `${extAgentId}.ts`);
+			const extAgentContent = generateExternalAgentFile(extAgentId, extAgentData, style, registry);
+			ensureDir(extAgentFile);
+			writeFileSync(extAgentFile, extAgentContent, "utf-8");
+			generatedFiles.push(extAgentFile);
+		}
+		const registeredContextConfigs = registry.getAllComponents().filter((c) => c.type === "contextConfigs");
+		if (registeredContextConfigs.length > 0) for (const contextComp of registeredContextConfigs) {
+			const contextData = findContextConfigData(project, contextComp.id);
+			if (contextData) {
+				const contextFile = join(paths.contextConfigsDir, `${contextComp.id}.ts`);
+				const contextContent = generateContextConfigFile(contextComp.id, contextData, style, registry);
+				ensureDir(contextFile);
+				writeFileSync(contextFile, contextContent, "utf-8");
+				generatedFiles.push(contextFile);
+			}
+		}
+		const completeAgentIds = /* @__PURE__ */ new Set();
+		if (project.agents) for (const [agentId, agentData] of Object.entries(project.agents)) {
+			const completeness = isAgentComplete(agentId, agentData);
+			if (completeness.complete) completeAgentIds.add(agentId);
+			else {
+				skippedAgents.push({
+					id: agentId,
+					reason: completeness.reason || "incomplete"
+				});
+				if (debug) console.log(chalk.yellow(`⚠️  Skipping incomplete agent '${agentId}': ${completeness.reason}`));
+			}
+		}
+		if (project.agents && Object.keys(project.agents).length > 0) {
+			let totalSubAgents = 0;
+			for (const [agentId, agentData] of Object.entries(project.agents)) {
+				if (!completeAgentIds.has(agentId)) continue;
+				if (agentData.subAgents) for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) totalSubAgents++;
+			}
+			if (totalSubAgents > 0) for (const [agentId, agentData] of Object.entries(project.agents)) {
+				if (!completeAgentIds.has(agentId)) continue;
+				if (agentData.subAgents) {
+					const contextConfigData = agentData.contextConfig?.id ? findContextConfigData(project, agentData.contextConfig.id) : void 0;
+					for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) {
+						const subAgentFile = join(paths.agentsDir, "sub-agents", `${subAgentId}.ts`);
+						const subAgentContent = generateSubAgentFile(subAgentId, subAgentData, style, registry, agentId, contextConfigData, agentData.models || project.models);
+						ensureDir(subAgentFile);
+						writeFileSync(subAgentFile, subAgentContent, "utf-8");
+						generatedFiles.push(subAgentFile);
+					}
+				}
+			}
+		}
+		if (project.agents) for (const [agentId, agentData] of Object.entries(project.agents)) {
+			if (!completeAgentIds.has(agentId)) continue;
+			const agentFile = join(paths.agentsDir, `${agentId}.ts`);
+			const agentContent = generateAgentFile(agentId, agentData, style, registry, agentData.contextConfig?.id ? findContextConfigData(project, agentData.contextConfig.id) : void 0, project.models);
+			ensureDir(agentFile);
+			writeFileSync(agentFile, agentContent, "utf-8");
+			generatedFiles.push(agentFile);
+		}
+		const projectDataForGenerator = {
+			...project,
+			agents: project.agents ? Object.keys(project.agents).filter((id) => completeAgentIds.has(id)) : [],
+			tools: project.tools ? Object.keys(project.tools) : [],
+			externalAgents: project.externalAgents ? Object.keys(project.externalAgents) : [],
+			dataComponents: project.dataComponents ? Object.keys(project.dataComponents) : [],
+			artifactComponents: project.artifactComponents ? Object.keys(project.artifactComponents) : [],
+			credentialReferences: project.credentialReferences ? Object.keys(project.credentialReferences) : []
+		};
+		const projectFile = join(paths.projectRoot, "index.ts");
+		const projectContent = generateProjectFile(project.id, projectDataForGenerator, style, registry);
+		ensureDir(projectFile);
+		writeFileSync(projectFile, projectContent, "utf-8");
+		generatedFiles.push(projectFile);
+		if (debug) console.log(chalk.green(`✅ Generated ${generatedFiles.length} files`));
+		if (skippedAgents.length > 0) {
+			console.log(chalk.yellow(`\n⚠️  Skipped ${skippedAgents.length} incomplete agent(s):`));
+			for (const { id, reason } of skippedAgents) console.log(chalk.yellow(`   • ${id}: ${reason}`));
+			console.log(chalk.gray("   To fix: Add at least one sub-agent to each agent in the UI and set it as default."));
+		}
+	} catch (error) {
+		console.error(chalk.red("\n❌ Introspect regeneration failed:"));
+		console.error(chalk.red(`   Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+		throw error;
+	}
+}
+/**
+* Find context config data by agent-based ID from project agents
+*/
+function findContextConfigData(project, contextId) {
+	if (project.agents) {
+		for (const [agentId, agentData] of Object.entries(project.agents)) if (agentData.contextConfig) {
+			if (agentData.contextConfig.id === contextId) return agentData.contextConfig;
+		}
+	}
+}
+/**
+* Find status component data by ID from project agents
+*/
+function findStatusComponentData(project, statusId) {
+	if (project.agents) {
+		for (const [agentId, agentData] of Object.entries(project.agents)) if (agentData.statusUpdates && agentData.statusUpdates.statusComponents) for (const statusComp of agentData.statusUpdates.statusComponents) {
+			let compId;
+			if (typeof statusComp === "string") compId = statusComp;
+			else if (typeof statusComp === "object" && statusComp) compId = statusComp.type;
+			if (compId === statusId) return typeof statusComp === "string" ? {
+				id: statusId,
+				type: statusId,
+				description: `Status component for ${statusId}`
+			} : statusComp;
+		}
+	}
+}
+
+//#endregion
+export { introspectGenerate };

package/dist/commands/pull-v3/llm-content-merger.js

@@ -0,0 +1,192 @@
+import { createTargetedTypeScriptPlaceholders, restoreTargetedTypeScriptPlaceholders } from "./targeted-typescript-placeholders.js";
+import { getAvailableModel } from "./utils/model-provider-detector.js";
+import chalk from "chalk";
+import { generateText } from "ai";
+
+//#region src/commands/pull-v3/llm-content-merger.ts
+/**
+* LLM Content Merger - Intelligently merge old and new component content
+*
+* Uses an LLM to selectively update modified components while preserving:
+* - Original file structure and formatting
+* - Code style consistency
+* - Better zod schemas
+* - Imports and other non-component code
+*/
+/**
+* Strip code fences from LLM response if present
+*/
+function stripCodeFences(content) {
+	content = content.replace(/^```(?:typescript|ts|javascript|js)?\s*\n?/i, "");
+	content = content.replace(/\n?```\s*$/i, "");
+	return content;
+}
+/**
+* Estimate tokens in text (rough approximation: 1 token ≈ 4 characters)
+*/
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+function calculateCostEstimate(promptTokens, completionTokens) {
+	return promptTokens / 1e6 * 3 + completionTokens / 1e6 * 15;
+}
+/**
+* Use LLM to intelligently merge old content with new component definitions
+*/
+async function mergeComponentsWithLLM(request) {
+	const { oldContent, newContent, modifiedComponents, filePath, newComponents, componentsToExport } = request;
+	const componentList = modifiedComponents.map((c) => `- ${c.componentType}:${c.componentId}`).join("\n");
+	const newComponentsList = newComponents && newComponents.length > 0 ? newComponents.map((c) => {
+		const currentDir = filePath.replace(/^.*\/([^/]+\/[^/]+)$/, "$1").replace(/\/[^/]+$/, "");
+		let componentPath = c.filePath;
+		if (componentPath.includes(".temp-")) componentPath = componentPath.replace(/^.*\.temp-[^/]+\//, "");
+		componentPath = componentPath.replace(/\.ts$/, "");
+		const importPath = calculateRelativeImportPath(currentDir, componentPath);
+		const variableName = c.componentId.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+		return `- ${c.componentType}:${c.componentId} (import as: import { ${variableName} } from '${importPath}')`;
+	}).join("\n") : "";
+	function calculateRelativeImportPath(fromDir, toPath) {
+		const fromParts = fromDir.split("/");
+		const toParts = toPath.split("/");
+		let commonLength = 0;
+		while (commonLength < fromParts.length && commonLength < toParts.length - 1 && fromParts[commonLength] === toParts[commonLength]) commonLength++;
+		const upLevels = fromParts.length - commonLength;
+		let relativePath = "";
+		for (let i = 0; i < upLevels; i++) relativePath += "../";
+		relativePath += toParts.slice(commonLength).join("/");
+		return relativePath.startsWith("../") ? relativePath : "./" + relativePath;
+	}
+	const componentsToExportList = componentsToExport && componentsToExport.length > 0 ? componentsToExport.map((c) => `- ${c.variableName} (${c.reason})`).join("\n") : "";
+	const prompt = `You are a TypeScript code expert tasked with intelligently merging component updates.
+
+## Task
+Merge the OLD file content with NEW component definitions, preserving the original file structure while updating only the modified components.
+
+## Modified Components to Update
+${componentList}
+${newComponentsList ? `
+## New Components Available (can be imported)
+${newComponentsList}
+` : ""}${componentsToExportList ? `
+## Components That Need To Be Exported
+The following existing components are referenced by new components and must be exported:
+${componentsToExportList}
+
+Ensure these components have export statements (convert \`const\` to \`export const\`, or add \`export\` to existing declarations).
+` : ""}
+## Instructions
+0. **Please ensure you focus changes to minimize git diff size.** We want a clean git history.
+1. **Preserve original structure**: Keep imports, exports, comments, and overall file organization
+2. **Update only modified components**: Replace the specified components with their new versions
+3. **Maintain code style**: Match the original formatting, indentation, and style
+4. **Improve schemas**: Use better zod schemas from the new content where applicable. E.g. if the new content uses something like z.union([z.null(), z.string()]), use z.string().nullable() instead. 
+5. **Keep variable names**: Preserve original variable names and declarations
+6. **Preserve non-component code**: Keep any non-component logic, comments, or utilities
+7. **Smart import handling**: 
+   - Please leave all imports at the top of the file. Don't use .js imports, use .ts imports instead. (import example from './example')
+   - Preserve all imports from the original content that are not modified, if a component is modified or no longer exists, remove the import.
+   - For NEW components listed above, add proper import statements
+   - For components that exist in the same file (modified components), DO NOT add import statements
+   - Remove any incorrect imports from the NEW component definitions that reference same-file components
+   - Use relative paths for imports (e.g., './example' not './example.js')
+8. **Format JavaScript functions for maximum readability**:
+   - When you see compressed/minified function code like \`async({params})=>{...code...}\`, expand and prettify it
+   - Add proper line breaks, spacing, and indentation to make the function readable
+   - Ensure all braces \`{}\`, parentheses \`()\`, and syntax are properly balanced and valid
+   - Format the function code following TypeScript/JavaScript best practices
+   - Make sure the final code is compilable and syntactically correct
+   - Example: \`async({a,b})=>{return a+b}\` should become:
+     \`\`\`
+     async ({ a, b }) => {
+       return a + b;
+     }
+     \`\`\`
+
+## OLD File to be updated with new component definitions:
+\`\`\`typescript
+${oldContent}
+\`\`\`
+
+## NEW Component Definitions to replace/add to the old file:
+\`\`\`typescript
+${newContent}
+\`\`\`
+
+## Output
+Provide the merged TypeScript file that:
+- Keeps the original file structure
+- Updates ONLY the modified components listed above
+- Maintains consistent code style
+- Uses improved schemas where beneficial
+- Preserves all imports, exports, and other code that are necessary to keep the file working.
+- **Formats all function code beautifully with proper spacing, line breaks, and indentation**
+- **Ensures all syntax is valid and compilable TypeScript/JavaScript**
+- Start the code immidiately with the first line of the file, skip any backticks or other formatting announcing that it is a code block or typescript file.
+- Please follow biomes.dev code style.
+- Please remember the NEW component definitions are to replace/add to the old file.
+
+Return only the merged TypeScript code without any explanation or markdown formatting.`;
+	try {
+		const oldPlaceholders = createTargetedTypeScriptPlaceholders(oldContent);
+		const newPlaceholders = createTargetedTypeScriptPlaceholders(newContent);
+		const processedPrompt = prompt.replace(oldContent, oldPlaceholders.processedContent).replace(newContent, newPlaceholders.processedContent);
+		const estimatedPromptTokens = estimateTokens(processedPrompt);
+		let mergedContent = (await generateText({
+			model: getAvailableModel(),
+			prompt: processedPrompt
+		})).text.trim();
+		mergedContent = stripCodeFences(mergedContent);
+		const estimatedCompletionTokens = estimateTokens(mergedContent);
+		const totalTokens = estimatedPromptTokens + estimatedCompletionTokens;
+		const estimatedCost = calculateCostEstimate(estimatedPromptTokens, estimatedCompletionTokens);
+		console.log(chalk.gray(`   💰 LLM usage: ~${totalTokens.toLocaleString()} tokens ($${estimatedCost.toFixed(4)})`));
+		const allReplacements = {
+			...oldPlaceholders.replacements,
+			...newPlaceholders.replacements
+		};
+		if (Object.keys(allReplacements).length > 0) mergedContent = restoreTargetedTypeScriptPlaceholders(mergedContent, allReplacements);
+		const changes = modifiedComponents.map((c) => `Updated ${c.componentType}:${c.componentId}`);
+		return {
+			mergedContent,
+			changes,
+			success: true,
+			usage: {
+				promptTokens: estimatedPromptTokens,
+				completionTokens: estimatedCompletionTokens,
+				totalTokens,
+				estimatedCost
+			}
+		};
+	} catch (error) {
+		return {
+			mergedContent: oldContent,
+			changes: [],
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Preview the merge result by showing a diff-like summary
+*/
+function previewMergeResult(oldContent, mergedContent, changes) {
+	console.log(chalk.cyan("\n🔍 Merge Preview:"));
+	console.log(chalk.gray(`   Old content: ${oldContent.length} characters`));
+	console.log(chalk.gray(`   New content: ${mergedContent.length} characters`));
+	console.log(chalk.yellow(`   Changes applied:`));
+	changes.forEach((change) => {
+		console.log(chalk.gray(`     • ${change}`));
+	});
+	const lines = mergedContent.split("\n");
+	const preview = lines.slice(0, 10).join("\n");
+	console.log(chalk.cyan("\n📄 Merged content preview (first 10 lines):"));
+	console.log(chalk.gray("   ┌─────"));
+	preview.split("\n").forEach((line, i) => {
+		console.log(chalk.gray(`   │ ${String(i + 1).padStart(2, " ")}: ${line}`));
+	});
+	if (lines.length > 10) console.log(chalk.gray(`   │ ... (${lines.length - 10} more lines)`));
+	console.log(chalk.gray("   └─────"));
+}
+
+//#endregion
+export { mergeComponentsWithLLM, previewMergeResult };

package/dist/{new-component-generator.js → commands/pull-v3/new-component-generator.js}

@@ -1,5 +1,16 @@
-#!/usr/bin/env node
-import { C as generateCredentialFile, D as toCamelCase, E as generateAgentFile, S as generateDataComponentFile, T as generateArtifactComponentFile, c as findSubAgentWithParent, f as generateMcpToolFile, h as generateEnvironmentFile, l as generateSubAgentFile, m as generateExternalAgentFile, p as generateFunctionToolFile, u as generateStatusComponentFile, w as generateContextConfigFile } from "./index.js";
+import { toCamelCase } from "./utils/generator-utils.js";
+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 { generateStatusComponentFile } from "./components/status-component-generator.js";
+import { generateSubAgentFile } from "./components/sub-agent-generator.js";
+import { findSubAgentWithParent } from "./utils/component-registry.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
@@ -218,7 +229,7 @@ async function createNewComponents(comparison, remoteProject, localRegistry, pat
 	const createdEnvironments = results.filter((r) => r.success && r.componentType === "environments");
 	if (createdEnvironments.length > 0) try {
 		console.log(chalk.cyan("📝 Generating environments index file..."));
-		const { generateEnvironmentIndexFile } = await import("./environment-generator.js");
+		const { generateEnvironmentIndexFile } = await import("./components/environment-generator.js");
 		const indexContent = generateEnvironmentIndexFile(createdEnvironments.map((r) => r.componentId), {
 			quotes: "single",
 			indentation: "  ",