@inkeep/agents-cli 0.39.5 → 0.41.0

package/dist/{project-index-generator.js → commands/pull-v3/project-index-generator.js}

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-import { d as generateProjectFile } from "./index.js";
+import { generateProjectFile } from "./components/project-generator.js";
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 

package/dist/{project-validator.js → commands/pull-v3/project-validator.js}

@@ -1,6 +1,6 @@
-#!/usr/bin/env node
-import { n as compareProjects, t as enrichCanDelegateToWithTypes } from "./index.js";
-import { t as buildComponentRegistryFromParsing } from "./component-parser2.js";
+import { buildComponentRegistryFromParsing } from "./component-parser.js";
+import { compareProjects } from "./project-comparator.js";
+import { enrichCanDelegateToWithTypes } from "./index.js";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
@@ -138,7 +138,7 @@ function getComponentFromProject(project, componentType, componentId) {
 */
 async function validateProjectEquivalence(tempDir, remoteProject) {
 	try {
-		const { loadProject } = await import("./project-loader.js");
+		const { loadProject } = await import("../../utils/project-loader.js");
 		const tempProject = await loadProject(tempDir);
 		const tempProjectDefinition = await Promise.race([tempProject.getFullDefinition(), new Promise((_, reject) => {
 			setTimeout(() => {

package/dist/commands/pull-v3/targeted-typescript-placeholders.js

@@ -0,0 +1,173 @@
+import { randomBytes } from "node:crypto";
+import { Node, Project } from "ts-morph";
+
+//#region src/commands/pull-v3/targeted-typescript-placeholders.ts
+/**
+* Targeted TypeScript Placeholder System
+*
+* Uses AST parsing to intelligently identify large content blocks for replacement:
+* - prompt: (template literals or strings)
+* - description: (string literals)
+* - inputSchema: (object literals)
+* - detailsSchema: (object literals)
+* - props: (object literals in artifact/data components)
+*/
+/**
+* Generate a unique placeholder ID
+*/
+function generatePlaceholderId() {
+	return randomBytes(4).toString("hex").toUpperCase();
+}
+/**
+* Minimum length threshold for replacement (only replace if longer than this)
+*/
+const MIN_REPLACEMENT_LENGTH = 10;
+/**
+* Create targeted placeholders using AST parsing for better accuracy
+*/
+function createTargetedTypeScriptPlaceholders(content, debug = false) {
+	const replacements = {};
+	let replacedFields = 0;
+	const originalSize = content.length;
+	try {
+		const sourceFile = new Project({ useInMemoryFileSystem: true }).createSourceFile("temp.ts", content);
+		const replacementOperations = [];
+		sourceFile.forEachDescendant((node) => {
+			if (Node.isPropertyAssignment(node)) {
+				const propertyName = node.getName();
+				const valueNode = node.getInitializer();
+				if (!valueNode) return;
+				let valueText = valueNode.getText();
+				if (valueText.trim().length < MIN_REPLACEMENT_LENGTH) return;
+				let placeholderPrefix = "";
+				switch (propertyName) {
+					case "prompt":
+						placeholderPrefix = "PROMPT";
+						break;
+					case "description":
+						placeholderPrefix = "DESC";
+						break;
+					case "inputSchema":
+						placeholderPrefix = "INPUT_SCHEMA";
+						break;
+					case "detailsSchema":
+						placeholderPrefix = "DETAILS_SCHEMA";
+						break;
+					case "props":
+						placeholderPrefix = "PROPS";
+						break;
+					case "render":
+						placeholderPrefix = "RENDER";
+						break;
+					default: return;
+				}
+				const start = valueNode.getStart();
+				let end = valueNode.getEnd();
+				const propertyEnd = node.getEnd();
+				if (propertyName === "inputSchema" || propertyName === "render") {
+					const searchStart = start;
+					let braceCount = 0;
+					let correctEnd = -1;
+					let inString = false;
+					let stringChar = "";
+					for (let i = searchStart; i < content.length; i++) {
+						const char = content[i];
+						const prevChar = i > 0 ? content[i - 1] : "";
+						if ((char === "\"" || char === "'") && prevChar !== "\\") {
+							if (!inString) {
+								inString = true;
+								stringChar = char;
+							} else if (char === stringChar) {
+								inString = false;
+								stringChar = "";
+							}
+						}
+						if (!inString) {
+							if (char === "{") braceCount++;
+							else if (char === "}") {
+								braceCount--;
+								if (braceCount === 0) {
+									let j = i + 1;
+									while (j < content.length && /\s/.test(content[j])) j++;
+									if (j < content.length && content[j] === ",") {
+										correctEnd = j + 1;
+										break;
+									}
+								}
+							}
+						}
+					}
+					if (correctEnd > start && correctEnd < end + 100) {
+						end = correctEnd;
+						valueText = content.slice(start, end);
+					}
+				} else if (!content.slice(end, end + 20).match(/^\s*[,}]/)) {
+					let correctEnd = end;
+					while (correctEnd > start && !content.slice(correctEnd, correctEnd + 10).match(/^\s*[,}]/)) correctEnd--;
+					if (correctEnd > start) {
+						end = correctEnd;
+						valueText = content.slice(start, end);
+					} else return;
+				}
+				if (end > propertyEnd) return;
+				const actualText = content.slice(start, end);
+				if (valueText !== actualText) return;
+				if (!content.slice(end, end + 20).match(/^\s*[,}]/)) return;
+				const placeholder = `<${placeholderPrefix}_${generatePlaceholderId()}>`;
+				replacements[placeholder] = valueText;
+				replacedFields++;
+				replacementOperations.push({
+					start,
+					end,
+					placeholder,
+					originalText: valueText
+				});
+			}
+		});
+		replacementOperations.sort((a, b) => b.start - a.start);
+		let processedContent = content;
+		for (const op of replacementOperations) processedContent = processedContent.slice(0, op.start) + op.placeholder + processedContent.slice(op.end);
+		const processedSize = processedContent.length;
+		const savings = originalSize - processedSize;
+		const savingsPercentage = originalSize > 0 ? savings / originalSize * 100 : 0;
+		return {
+			processedContent,
+			replacements,
+			stats: {
+				originalSize,
+				processedSize,
+				savings,
+				savingsPercentage,
+				replacedFields
+			}
+		};
+	} catch (error) {
+		return {
+			processedContent: content,
+			replacements: {},
+			stats: {
+				originalSize,
+				processedSize: originalSize,
+				savings: 0,
+				savingsPercentage: 0,
+				replacedFields: 0
+			}
+		};
+	}
+}
+/**
+* Restore placeholders in TypeScript content
+*/
+function restoreTargetedTypeScriptPlaceholders(content, replacements) {
+	let restoredContent = content;
+	const sortedPlaceholders = Object.keys(replacements).sort((a, b) => b.length - a.length);
+	for (const placeholder of sortedPlaceholders) {
+		const originalValue = replacements[placeholder];
+		if (!restoredContent.includes(placeholder)) continue;
+		restoredContent = restoredContent.replace(placeholder, originalValue);
+	}
+	return restoredContent;
+}
+
+//#endregion
+export { createTargetedTypeScriptPlaceholders, restoreTargetedTypeScriptPlaceholders };

package/dist/commands/pull-v3/utils/component-registry.js

@@ -0,0 +1,369 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/commands/pull-v3/utils/component-registry.ts
+var ComponentRegistry = class {
+	components = /* @__PURE__ */ new Map();
+	componentsByTypeAndId = /* @__PURE__ */ new Map();
+	usedNames = /* @__PURE__ */ new Set();
+	/**
+	* Register a component with both unique name and file path
+	*/
+	register(id, type, filePath, exportName, isInline = false) {
+		const typeKey = `${type}:${id}`;
+		const existing = this.componentsByTypeAndId.get(typeKey);
+		if (existing) return existing;
+		let name;
+		let actualExportName;
+		if (exportName) {
+			name = exportName;
+			actualExportName = exportName;
+		} else {
+			const baseName = this.toCamelCase(id);
+			const uniqueName = this.ensureUniqueName(baseName, type);
+			name = uniqueName;
+			actualExportName = uniqueName;
+		}
+		const info = {
+			id,
+			name,
+			type,
+			filePath,
+			exportName: actualExportName,
+			isInline
+		};
+		this.components.set(id, info);
+		this.componentsByTypeAndId.set(typeKey, info);
+		this.usedNames.add(name);
+		if (actualExportName && actualExportName !== name) this.usedNames.add(actualExportName);
+		return info;
+	}
+	/**
+	* Override a credential component with environment settings key
+	* This allows env settings registration to take precedence over standalone credentials
+	*/
+	overrideCredentialWithEnvKey(id, filePath, envKey) {
+		const typeKey = `credentials:${id}`;
+		const info = {
+			id,
+			type: "credentials",
+			name: envKey,
+			filePath,
+			exportName: envKey,
+			isInline: true
+		};
+		this.componentsByTypeAndId.set(typeKey, info);
+		this.components.set(`${filePath}:${envKey}`, info);
+		return info;
+	}
+	/**
+	* Get component info by ID and type
+	*/
+	get(id, type) {
+		const typeKey = `${type}:${id}`;
+		return this.componentsByTypeAndId.get(typeKey);
+	}
+	/**
+	* Get component info by variable name (since variable names are globally unique)
+	*/
+	getByVariableName(variableName) {
+		for (const component of this.componentsByTypeAndId.values()) if (component.name === variableName) return component;
+	}
+	/**
+	* Get unique variable name for a component by ID and type
+	*/
+	getVariableName(id, type) {
+		const typeKey = `${type}:${id}`;
+		return this.componentsByTypeAndId.get(typeKey)?.name;
+	}
+	/**
+	* Get import statement for a component
+	*/
+	getImportStatement(fromFilePath, componentId, componentType) {
+		const component = this.get(componentId, componentType);
+		if (!component) return void 0;
+		if (this.normalizeToProjectPath(fromFilePath) === this.normalizeToProjectPath(component.filePath)) return;
+		const relativePath = this.calculateRelativeImport(fromFilePath, component.filePath);
+		return `import { ${component.exportName} } from '${relativePath}';`;
+	}
+	/**
+	* Format an array of references for code generation
+	*/
+	formatReferencesForCode(references, componentType, style, indentLevel) {
+		if (!Array.isArray(references) || references.length === 0) return "[]";
+		const variableNames = [];
+		for (const ref of references) {
+			const id = this.extractIdFromReference(ref);
+			if (id) {
+				const component = this.get(id, componentType);
+				if (component) variableNames.push(component.name);
+				else {
+					console.warn(`ComponentRegistry: Component not found: ${id} (type: ${componentType})`);
+					variableNames.push(this.toCamelCase(id));
+				}
+			}
+		}
+		if (variableNames.length === 0) return "[]";
+		if (variableNames.length === 1) return `[${variableNames[0]}]`;
+		const { indentation } = style;
+		const indent = indentation.repeat(indentLevel);
+		const lines = ["["];
+		for (let i = 0; i < variableNames.length; i++) {
+			const isLast = i === variableNames.length - 1;
+			lines.push(`${indent}${variableNames[i]}${isLast ? "" : ","}`);
+		}
+		lines.push(`${indentation.repeat(indentLevel - 1)}]`);
+		return lines.join("\n");
+	}
+	/**
+	* Get all import statements needed for a file
+	*/
+	getImportsForFile(fromFilePath, referencedComponents) {
+		const imports = [];
+		const seenImports = /* @__PURE__ */ new Set();
+		for (const { id, type } of referencedComponents) {
+			const importStatement = this.getImportStatement(fromFilePath, id, type);
+			if (importStatement && !seenImports.has(importStatement)) {
+				imports.push(importStatement);
+				seenImports.add(importStatement);
+			}
+		}
+		return imports;
+	}
+	/**
+	* Get all component IDs referenced in arrays for import generation
+	*/
+	getReferencedComponentIds(referenceArrays) {
+		const componentIds = [];
+		for (const refArray of referenceArrays) if (Array.isArray(refArray)) for (const ref of refArray) {
+			const id = this.extractIdFromReference(ref);
+			if (id) componentIds.push(id);
+		}
+		return componentIds;
+	}
+	/**
+	* Extract ID from a reference (string or object) based on component type
+	*/
+	extractIdFromReference(ref) {
+		if (typeof ref === "string") return ref;
+		if (typeof ref === "object" && ref) {
+			if (ref.toolId) return ref.toolId;
+			if (ref.agentId) return ref.agentId;
+			if (ref.externalAgentId) return ref.externalAgentId;
+			if (ref.credentialStoreId) return ref.credentialStoreId;
+			if (ref.type && !ref.agentId && !ref.toolId && !ref.externalAgentId) return ref.type;
+			if (ref.id) return ref.id;
+			if (ref.name) return ref.name;
+			console.warn("ComponentRegistry: Reference without recognized ID field:", ref);
+			return null;
+		}
+		return null;
+	}
+	/**
+	* Convert string to camelCase and ensure it's a valid JavaScript identifier
+	*/
+	toCamelCase(str) {
+		return str.toLowerCase().replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
+	}
+	/**
+	* Ensure a name is unique by adding prefixes/suffixes if needed
+	*/
+	ensureUniqueName(baseName, type) {
+		let uniqueName = baseName;
+		let counter = 1;
+		while (this.usedNames.has(uniqueName)) {
+			if (counter === 1) uniqueName = `${this.getTypePrefix(type)}${baseName.charAt(0).toUpperCase() + baseName.slice(1)}`;
+			else uniqueName = `${baseName}${counter}`;
+			counter++;
+			if (counter > 100) {
+				uniqueName = `${baseName}_${Date.now()}`;
+				break;
+			}
+		}
+		return uniqueName;
+	}
+	/**
+	* Get type prefix for uniqueness resolution
+	*/
+	getTypePrefix(type) {
+		switch (type) {
+			case "agents": return "agent";
+			case "subAgents": return "sub";
+			case "externalAgents": return "ext";
+			case "tools": return "tool";
+			case "functionTools": return "func";
+			case "functions": return "func";
+			case "dataComponents": return "data";
+			case "artifactComponents": return "artifact";
+			case "statusComponents": return "status";
+			case "environments": return "env";
+			case "credentials": return "cred";
+			case "contextConfigs": return "context";
+			case "fetchDefinitions": return "fetch";
+			case "headers": return "header";
+			case "models": return "model";
+			case "project": return "project";
+			default: return "comp";
+		}
+	}
+	/**
+	* Normalize path to project-relative format using existing registry paths as templates
+	*/
+	normalizeToProjectPath(filePath) {
+		if (!filePath.includes("/") || filePath.match(/^(agents|tools|environments|data-components)/)) return filePath;
+		const knownDirs = /* @__PURE__ */ new Set();
+		for (const component of this.components.values()) {
+			const firstDir = component.filePath.split("/")[0];
+			if (firstDir) knownDirs.add(firstDir);
+		}
+		const segments = filePath.split("/");
+		for (let i = segments.length - 1; i >= 0; i--) if (knownDirs.has(segments[i])) return segments.slice(i).join("/");
+		return segments[segments.length - 1] || filePath;
+	}
+	/**
+	* Calculate relative import path between files
+	*/
+	calculateRelativeImport(fromPath, toPath) {
+		const fromParts = fromPath.replace(".ts", "").split("/");
+		const toParts = toPath.replace(".ts", "").split("/");
+		const fromDir = fromParts.slice(0, -1);
+		const toFile = toParts;
+		let commonLength = 0;
+		while (commonLength < fromDir.length && commonLength < toFile.length - 1 && fromDir[commonLength] === toFile[commonLength]) commonLength++;
+		let relativePath = "";
+		const upLevels = fromDir.length - commonLength;
+		for (let i = 0; i < upLevels; i++) relativePath += "../";
+		const remainingPath = toFile.slice(commonLength).join("/");
+		relativePath += remainingPath;
+		if (relativePath.startsWith("../")) return relativePath;
+		return "./" + relativePath;
+	}
+	/**
+	* Get all components for debugging
+	*/
+	getAllComponents() {
+		return Array.from(this.componentsByTypeAndId.values());
+	}
+	/**
+	* Get all components in a specific file
+	*/
+	getComponentsInFile(filePath) {
+		return Array.from(this.componentsByTypeAndId.values()).filter((component) => component.filePath === filePath);
+	}
+	/**
+	* Remove a component from the registry
+	*/
+	removeComponent(type, id) {
+		const key = `${type}:${id}`;
+		const component = this.componentsByTypeAndId.get(key);
+		if (component) {
+			this.componentsByTypeAndId.delete(key);
+			this.components.delete(component.name);
+			if (!Array.from(this.componentsByTypeAndId.values()).some((comp) => comp.name === component.name)) this.usedNames.delete(component.name);
+		}
+	}
+	/**
+	* Clear all components (for testing)
+	*/
+	clear() {
+		this.components.clear();
+		this.componentsByTypeAndId.clear();
+		this.usedNames.clear();
+	}
+};
+/**
+* Register all components from a project with their file paths
+*/
+function registerAllComponents(project, registry) {
+	registry.register(project.id, "project", "index.ts");
+	if (project.credentialReferences) for (const credId of Object.keys(project.credentialReferences)) registry.register(credId, "credentials", `credentials/${credId}.ts`);
+	if (project.tools) for (const toolId of Object.keys(project.tools)) registry.register(toolId, "tools", `tools/${toolId}.ts`);
+	const registeredFunctionToolIds = /* @__PURE__ */ new Set();
+	if (project.functionTools) for (const funcToolId of Object.keys(project.functionTools)) {
+		registry.register(funcToolId, "functionTools", `tools/functions/${funcToolId}.ts`);
+		registeredFunctionToolIds.add(funcToolId);
+	}
+	if (project.agents) for (const agentData of Object.values(project.agents)) {
+		const agentFunctionTools = agentData.functionTools;
+		if (agentFunctionTools) {
+			for (const funcToolId of Object.keys(agentFunctionTools)) if (!registeredFunctionToolIds.has(funcToolId)) {
+				registry.register(funcToolId, "functionTools", `tools/functions/${funcToolId}.ts`);
+				registeredFunctionToolIds.add(funcToolId);
+			}
+		}
+	}
+	if (project.dataComponents) for (const componentId of Object.keys(project.dataComponents)) registry.register(componentId, "dataComponents", `data-components/${componentId}.ts`);
+	if (project.artifactComponents) for (const componentId of Object.keys(project.artifactComponents)) registry.register(componentId, "artifactComponents", `artifact-components/${componentId}.ts`);
+	if (project.externalAgents) for (const extAgentId of Object.keys(project.externalAgents)) registry.register(extAgentId, "externalAgents", `external-agents/${extAgentId}.ts`);
+	const statusComponents = extractStatusComponents(project);
+	for (const statusId of Object.keys(statusComponents)) registry.register(statusId, "statusComponents", `status-components/${statusId}.ts`);
+	if (project.agents) for (const agentId of Object.keys(project.agents)) registry.register(agentId, "agents", `agents/${agentId}.ts`);
+	const subAgents = extractSubAgents(project);
+	for (const subAgentId of Object.keys(subAgents)) registry.register(subAgentId, "subAgents", `agents/sub-agents/${subAgentId}.ts`);
+	const contextConfigs = extractContextConfigs(project);
+	for (const contextId of Object.keys(contextConfigs)) registry.register(contextId, "contextConfigs", `context-configs/${contextId}.ts`);
+}
+/**
+* Extract status components from project agents
+*/
+function extractStatusComponents(project) {
+	const statusComponents = {};
+	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 statusId;
+			if (typeof statusComp === "string") statusId = statusComp;
+			else if (typeof statusComp === "object" && statusComp) statusId = statusComp.type;
+			else continue;
+			if (statusId && !statusComponents[statusId]) statusComponents[statusId] = {
+				...statusComp,
+				id: statusId,
+				type: statusComp.type || statusId,
+				description: statusComp.description || `Status component for ${statusId}`,
+				detailsSchema: statusComp.detailsSchema
+			};
+		}
+	}
+	return statusComponents;
+}
+/**
+* Extract sub-agents from project agents
+*/
+function extractSubAgents(project) {
+	const subAgents = {};
+	if (project.agents) {
+		for (const [agentId, agentData] of Object.entries(project.agents)) if (agentData.subAgents) for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) subAgents[subAgentId] = subAgentData;
+	}
+	return subAgents;
+}
+/**
+* Extract context configs from project agents
+*/
+function extractContextConfigs(project) {
+	const contextConfigs = {};
+	if (project.agents) {
+		for (const [agentId, agentData] of Object.entries(project.agents)) if (agentData.contextConfig) {
+			const contextConfigId = agentData.contextConfig.id;
+			if (contextConfigId) contextConfigs[contextConfigId] = agentData.contextConfig;
+			else console.warn(`contextConfig for agent ${agentId} is missing required 'id' field`);
+		}
+	}
+	return contextConfigs;
+}
+/**
+* Find sub-agent data with parent agent info for contextConfig resolution
+*/
+function findSubAgentWithParent(project, subAgentId) {
+	if (project.agents) {
+		for (const [agentId, agentData] of Object.entries(project.agents)) if (agentData.subAgents && agentData.subAgents[subAgentId]) {
+			const contextConfigData = agentData.contextConfig?.id ? agentData.contextConfig : void 0;
+			return {
+				subAgentData: agentData.subAgents[subAgentId],
+				parentAgentId: agentId,
+				contextConfigData
+			};
+		}
+	}
+}
+
+//#endregion
+export { ComponentRegistry, extractSubAgents, findSubAgentWithParent, registerAllComponents };