@inkeep/agents-cli 0.51.0 → 0.52.0

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

@@ -1,286 +0,0 @@
-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 { generateTriggerFile } from "./components/trigger-generator.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(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 agentData of Object.values(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 of Object.keys(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(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 of Object.keys(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);
-			if (agentData.triggers && Object.keys(agentData.triggers).length > 0) for (const [triggerId, triggerData] of Object.entries(agentData.triggers)) {
-				const triggerFile = join(paths.agentsDir, "triggers", `${triggerId}.ts`);
-				const triggerContent = generateTriggerFile(triggerId, triggerData, style, registry);
-				ensureDir(triggerFile);
-				writeFileSync(triggerFile, triggerContent, "utf-8");
-				generatedFiles.push(triggerFile);
-			}
-		}
-		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 agentData of Object.values(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 agentData of Object.values(project.agents)) if (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

@@ -1,192 +0,0 @@
-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 };