@inkeep/agents-cli 0.52.0 → 0.53.1

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

@@ -1,173 +0,0 @@
-import { Node, Project } from "ts-morph";
-import { randomBytes } from "node:crypto";
-
-//#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) {
-	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 {
-		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-tracker.js

@@ -1,165 +0,0 @@
-//#region src/commands/pull-v3/utils/component-tracker.ts
-var ComponentTracker = class {
-	components = /* @__PURE__ */ new Map();
-	usedNames = /* @__PURE__ */ new Set();
-	/**
-	* Register a component in the tracker
-	*/
-	register(info) {
-		const uniqueName = this.ensureUniqueName(info.name, info.type);
-		const uniqueExportName = this.ensureUniqueName(info.exportName, info.type);
-		const updatedInfo = {
-			...info,
-			name: uniqueName,
-			exportName: uniqueExportName
-		};
-		this.components.set(info.id, updatedInfo);
-		this.usedNames.add(uniqueName);
-		this.usedNames.add(uniqueExportName);
-	}
-	/**
-	* Ensure a variable name is unique across the project
-	*/
-	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 "agent": return "agent";
-			case "subAgent": return "sub";
-			case "externalAgent": return "ext";
-			case "tool": return "tool";
-			case "functionTool": return "func";
-			case "dataComponent": return "data";
-			case "artifactComponent": return "artifact";
-			case "credential": return "cred";
-			case "statusComponent": return "status";
-			case "contextConfig": return "context";
-			default: return "comp";
-		}
-	}
-	/**
-	* Get component info by ID
-	*/
-	get(id) {
-		return this.components.get(id);
-	}
-	/**
-	* Check if component exists
-	*/
-	has(id) {
-		return this.components.has(id);
-	}
-	/**
-	* Get all components of a specific type
-	*/
-	getByType(type) {
-		return Array.from(this.components.values()).filter((c) => c.type === type);
-	}
-	/**
-	* Extract IDs from mixed array (objects with id property or strings)
-	*/
-	extractIds(references) {
-		if (!Array.isArray(references)) return [];
-		return references.map((ref) => {
-			if (typeof ref === "string") return ref;
-			if (typeof ref === "object" && ref) {
-				if (ref.id) return ref.id;
-				if (ref.type) return ref.type;
-				if (ref.name) return ref.name;
-				console.warn("ComponentTracker: Skipping reference without clear ID:", ref);
-				return null;
-			}
-			return null;
-		}).filter(Boolean);
-	}
-	/**
-	* Resolve references to import statements and variable names
-	*/
-	resolveReferences(references, currentFilePath) {
-		const ids = this.extractIds(references);
-		const imports = [];
-		const variableNames = [];
-		for (const id of ids) {
-			const component = this.get(id);
-			if (component) {
-				const importPath = this.getRelativeImportPath(currentFilePath, component.filePath);
-				imports.push(`import { ${component.exportName} } from '${importPath}';`);
-				variableNames.push(component.name);
-			} else variableNames.push(id);
-		}
-		return {
-			imports,
-			variableNames
-		};
-	}
-	/**
-	* Generate formatted array of variable names for code generation
-	*/
-	formatReferencesForCode(references, style, indentLevel) {
-		const ids = this.extractIds(references);
-		const variableNames = [];
-		for (const id of ids) {
-			const component = this.get(id);
-			if (component) variableNames.push(component.name);
-			else variableNames.push(id);
-		}
-		if (variableNames.length === 0) return "[]";
-		const { indentation } = style;
-		const indent = indentation.repeat(indentLevel);
-		if (variableNames.length === 1) return `[${variableNames[0]}]`;
-		const lines = ["["];
-		for (const name of variableNames) lines.push(`${indent}${name},`);
-		if (lines.length > 1 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
-		lines.push(`${indentation.repeat(indentLevel - 1)}]`);
-		return lines.join("\n");
-	}
-	/**
-	* Calculate relative import path between files
-	*/
-	getRelativeImportPath(fromPath, toPath) {
-		const fromParts = fromPath.replace(".ts", "").split("/");
-		const toParts = toPath.replace(".ts", "").split("/");
-		fromParts.pop();
-		let relativePath = "";
-		for (let i = 0; i < fromParts.length; i++) relativePath += "../";
-		relativePath += toParts.join("/");
-		if (relativePath.startsWith("../")) return relativePath;
-		return `./${relativePath}`;
-	}
-	/**
-	* Get all components as a list
-	*/
-	getAllComponents() {
-		return Array.from(this.components.values());
-	}
-	/**
-	* Clear all registered components
-	*/
-	clear() {
-		this.components.clear();
-	}
-};
-/**
-* Convert kebab-case or snake_case to camelCase
-*/
-function toCamelCase(str) {
-	return str.toLowerCase().replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
-}
-
-//#endregion
-export { ComponentTracker, toCamelCase };

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

@@ -1,146 +0,0 @@
-//#region src/commands/pull-v3/utils/generator-utils.ts
-const DEFAULT_STYLE = {
-	quotes: "single",
-	semicolons: true,
-	indentation: "  "
-};
-/**
-* Convert kebab-case or snake_case to camelCase for variable names
-*/
-function toCamelCase(str) {
-	const result = str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
-	return result.charAt(0).toLowerCase() + result.slice(1);
-}
-/**
-* Format a string value with proper quoting and multiline handling
-*/
-function formatString(str, quote = "'", multiline = false) {
-	if (!str && str !== "") return `${quote}${quote}`;
-	if (multiline && (str.includes("\n") || str.length > 80)) return `\`${str.replace(/`/g, "\\`")}\``;
-	return `${quote}${str.replace(new RegExp(quote, "g"), `\\${quote}`)}${quote}`;
-}
-/**
-* Check if a string contains template variables like {{user.name}}
-*/
-function hasTemplateVariables(str) {
-	return /\{\{[^}]+\}\}/.test(str);
-}
-/**
-* Determine if a variable path exists in headers schema
-*/
-function isHeadersVariable(variablePath, contextConfigData) {
-	if (!contextConfigData?.headersSchema?.schema) return false;
-	const schemaStr = JSON.stringify(contextConfigData.headersSchema.schema);
-	return schemaStr.includes(`"${variablePath}"`) || schemaStr.includes(variablePath.split(".")[0]);
-}
-/**
-* Determine if a variable path exists in context variables
-*/
-function isContextVariable(variablePath, contextConfigData) {
-	if (!contextConfigData?.contextVariables) return false;
-	const topLevelVar = variablePath.split(".")[0];
-	return Object.keys(contextConfigData.contextVariables).includes(topLevelVar);
-}
-/**
-* Format prompt strings with appropriate context.toTemplate() or headers.toTemplate() based on actual schema structure
-*/
-function formatPromptWithContext(str, contextVarName, headersVarName, contextConfigData, quote = "'", multiline = false) {
-	if (!str && str !== "") return `${quote}${quote}`;
-	if (hasTemplateVariables(str)) return `\`${str.replace(/\{\{([^}]+)\}\}/g, (_match, variablePath) => {
-		if (isContextVariable(variablePath, contextConfigData)) return `\${${contextVarName}.toTemplate("${variablePath}")}`;
-		if (isHeadersVariable(variablePath, contextConfigData)) return `\${${headersVarName}.toTemplate("${variablePath}")}`;
-		return `\${${contextVarName}.toTemplate("${variablePath}")}`;
-	}).replace(/`/g, "\\`")}\``;
-	return formatString(str, quote, multiline);
-}
-/**
-* Format prompt strings with headers.toTemplate() only (for backwards compatibility)
-*/
-function formatPromptWithHeaders(str, headersVarName, quote = "'", multiline = false) {
-	if (!str && str !== "") return `${quote}${quote}`;
-	if (hasTemplateVariables(str)) return `\`${str.replace(/\{\{([^}]+)\}\}/g, `\${${headersVarName}.toTemplate("$1")}`).replace(/`/g, "\\`")}\``;
-	return formatString(str, quote, multiline);
-}
-/**
-* Format array of references (tools, agents, components) with proper indentation
-*/
-function formatReferencesArray(references, style, indentLevel) {
-	let refArray;
-	if (Array.isArray(references)) refArray = references.map((item) => {
-		if (typeof item === "string") return toCamelCase(item);
-		if (typeof item === "object" && item && item.id) return toCamelCase(item.id);
-		return toCamelCase(String(item));
-	});
-	else if (references && typeof references === "object") refArray = Object.keys(references).map((key) => toCamelCase(key));
-	else return "[]";
-	if (!refArray || refArray.length === 0) return "[]";
-	const { indentation } = style;
-	const indent = indentation.repeat(indentLevel);
-	if (refArray.length === 1) return `[${refArray[0]}]`;
-	const lines = ["["];
-	for (const ref of refArray) lines.push(`${indent}${ref},`);
-	if (lines.length > 1 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
-	lines.push(`${indentation.repeat(indentLevel - 1)}]`);
-	return lines.join("\n");
-}
-/**
-* Format object properties as JavaScript object literal
-*/
-function formatObject(obj, style, indentLevel) {
-	if (!obj || typeof obj !== "object") return "{}";
-	const { quotes, indentation } = style;
-	const q = quotes === "single" ? "'" : "\"";
-	const indent = indentation.repeat(indentLevel);
-	const lines = ["{"];
-	for (const [key, value] of Object.entries(obj)) {
-		if (value === null || value === void 0) continue;
-		const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : formatString(key, q);
-		if (typeof value === "string") lines.push(`${indent}${formattedKey}: ${formatString(value, q)},`);
-		else if (typeof value === "object") lines.push(`${indent}${formattedKey}: ${formatObject(value, style, indentLevel + 1)},`);
-		else lines.push(`${indent}${formattedKey}: ${JSON.stringify(value)},`);
-	}
-	if (lines.length > 1 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
-	lines.push(`${indentation.repeat(indentLevel - 1)}}`);
-	return lines.join("\n");
-}
-/**
-* Remove trailing comma from the last line in an array of lines
-*/
-function removeTrailingComma(lines) {
-	if (lines.length > 0 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
-}
-/**
-* Generate standard import statement with proper quoting and semicolons
-*/
-function generateImport(imports, from, style) {
-	const { quotes, semicolons } = style;
-	const q = quotes === "single" ? "'" : "\"";
-	const semi = semicolons ? ";" : "";
-	if (imports.length === 1) return `import { ${imports[0]} } from ${q}${from}${q}${semi}`;
-	return `import { ${imports.join(", ")} } from ${q}${from}${q}${semi}`;
-}
-/**
-* Check if a value is truthy and should be included in output
-*/
-function shouldInclude(value) {
-	if (value === null || value === void 0) return false;
-	if (Array.isArray(value) && value.length === 0) return false;
-	if (typeof value === "object" && Object.keys(value).length === 0) return false;
-	return true;
-}
-/**
-* Generate complete file content with imports and definitions
-*/
-function generateFileContent(imports, definitions) {
-	const content = [];
-	if (imports.length > 0) content.push(imports.join("\n"));
-	if (definitions.length > 0) {
-		if (content.length > 0) content.push("");
-		content.push(definitions.join("\n\n"));
-	}
-	content.push("");
-	return content.join("\n");
-}
-
-//#endregion
-export { DEFAULT_STYLE, formatObject, formatPromptWithContext, formatPromptWithHeaders, formatReferencesArray, formatString, generateFileContent, generateImport, hasTemplateVariables, removeTrailingComma, shouldInclude, toCamelCase };

package/dist/commands/pull-v3/utils/model-provider-detector.js

@@ -1,50 +0,0 @@
-import { anthropic } from "@ai-sdk/anthropic";
-import { google } from "@ai-sdk/google";
-import { openai } from "@ai-sdk/openai";
-
-//#region src/commands/pull-v3/utils/model-provider-detector.ts
-/**
-* Model Provider Detector - Detect available API keys and select appropriate models
-*/
-const PROVIDER_CONFIGS = [
-	{
-		name: "anthropic",
-		envVars: ["ANTHROPIC_API_KEY"],
-		model: "claude-sonnet-4-5"
-	},
-	{
-		name: "openai",
-		envVars: ["OPENAI_API_KEY"],
-		model: "gpt-5.1"
-	},
-	{
-		name: "google",
-		envVars: ["GOOGLE_GENERATIVE_AI_API_KEY"],
-		model: "gemini-2.5-flash"
-	},
-	{
-		name: "azure",
-		envVars: ["AZURE_API_KEY"],
-		model: ""
-	}
-];
-/**
-* Get a model instance for LLM content merging
-* Returns first available provider or throws if none available
-*/
-function getAvailableModel() {
-	for (const config of PROVIDER_CONFIGS) if (config.envVars.some((envVar) => {
-		const value = process.env[envVar];
-		return value && value.trim() !== "";
-	})) switch (config.name) {
-		case "anthropic": return anthropic(config.model);
-		case "openai": return openai(config.model);
-		case "google": return google(config.model);
-		case "azure": continue;
-		default: throw new Error(`Unknown provider: ${config.name}`);
-	}
-	throw new Error("No API keys detected. Please set ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or AZURE_API_KEY");
-}
-
-//#endregion
-export { getAvailableModel };