@inkeep/agents-cli 0.39.5 → 0.41.0

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

@@ -0,0 +1,165 @@
+//#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

@@ -0,0 +1,146 @@
+//#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

@@ -0,0 +1,44 @@
+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"
+	}
+];
+/**
+* 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);
+		default: throw new Error(`Unknown provider: ${config.name}`);
+	}
+	throw new Error("No API keys detected. Please set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY");
+}
+
+//#endregion
+export { getAvailableModel };

package/dist/commands/push.js

@@ -0,0 +1,326 @@
+import { env } from "../env.js";
+import { findAllConfigFiles, findConfigFile } from "../utils/config.js";
+import { initializeCommand } from "../utils/cli-pipeline.js";
+import { performBackgroundVersionCheck } from "../utils/background-version-check.js";
+import { loadProject } from "../utils/project-loader.js";
+import { loadEnvironmentCredentials } from "../utils/environment-loader.js";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+
+//#region src/commands/push.ts
+async function pushCommand(options) {
+	performBackgroundVersionCheck();
+	if (options.all) {
+		await pushAllProjects(options);
+		return;
+	}
+	const { config, profile } = await initializeCommand({
+		configPath: options.config,
+		profileName: options.profile,
+		tag: options.tag,
+		showSpinner: true,
+		spinnerText: "Loading configuration...",
+		logConfig: true,
+		quiet: options.quiet
+	});
+	const s = p.spinner();
+	try {
+		s.start("Detecting project...");
+		let projectDir;
+		if (options.project) {
+			projectDir = resolve(process.cwd(), options.project);
+			if (!existsSync(join(projectDir, "index.ts"))) {
+				s.stop(`No index.ts found in specified project directory: ${projectDir}`);
+				process.exit(1);
+			}
+		} else {
+			const currentDir = process.cwd();
+			if (existsSync(join(currentDir, "index.ts"))) projectDir = currentDir;
+			else {
+				const configFile = findConfigFile(currentDir, options.tag);
+				if (configFile) {
+					const configDir = dirname(configFile);
+					if (existsSync(join(configDir, "index.ts"))) projectDir = configDir;
+					else {
+						s.stop("No index.ts found in config directory");
+						console.error(chalk.yellow("Please run this command from a directory containing index.ts or use --project <path>"));
+						process.exit(1);
+					}
+				} else {
+					s.stop("No index.ts found in current directory");
+					console.error(chalk.yellow("Please run this command from a directory containing index.ts or use --project <path>"));
+					process.exit(1);
+				}
+			}
+		}
+		s.stop(`Project found: ${projectDir}`);
+		if (options.env) {
+			process.env.INKEEP_ENV = options.env;
+			s.start(`Setting environment to '${options.env}'...`);
+		}
+		const originalTenantId = process.env.INKEEP_TENANT_ID;
+		const originalApiUrl = process.env.INKEEP_API_URL;
+		process.env.INKEEP_TENANT_ID = config.tenantId;
+		process.env.INKEEP_API_URL = config.agentsManageApiUrl;
+		s.start("Loading project from index.ts...");
+		const project = await loadProject(projectDir);
+		if (originalTenantId !== void 0) process.env.INKEEP_TENANT_ID = originalTenantId;
+		else delete process.env.INKEEP_TENANT_ID;
+		if (originalApiUrl !== void 0) process.env.INKEEP_API_URL = originalApiUrl;
+		else delete process.env.INKEEP_API_URL;
+		s.stop("Project loaded successfully");
+		if (typeof project.setConfig === "function") project.setConfig(config.tenantId, config.agentsManageApiUrl, void 0, config.agentsManageApiKey);
+		if (options.env && typeof project.setCredentials === "function") {
+			s.start(`Loading credentials for environment '${options.env}'...`);
+			try {
+				const credentials = await loadEnvironmentCredentials(projectDir, options.env);
+				project.setCredentials(credentials);
+				s.stop("Project loaded with credentials");
+				console.log(chalk.gray(`  • Environment: ${options.env}`));
+				console.log(chalk.gray(`  • Credentials loaded: ${Object.keys(credentials).length}`));
+			} catch (error) {
+				s.stop("Failed to load environment credentials");
+				console.error(chalk.red("Error:"), error.message);
+				process.exit(1);
+			}
+		}
+		if (options.json) {
+			s.start("Generating project data JSON...");
+			try {
+				const projectDefinition = await project.getFullDefinition();
+				const jsonFilePath = join(projectDir, `project.json`);
+				await (await import("node:fs/promises")).writeFile(jsonFilePath, JSON.stringify(projectDefinition, null, 2));
+				s.stop(`Project data saved to ${jsonFilePath}`);
+				console.log(chalk.gray(`  • File: ${jsonFilePath}`));
+				console.log(chalk.gray(`  • Size: ${JSON.stringify(projectDefinition).length} bytes`));
+				const agentCount = Object.keys(projectDefinition.agents || {}).length;
+				const toolCount = Object.keys(projectDefinition.tools || {}).length;
+				const subAgentCount = Object.values(projectDefinition.agents || {}).reduce((total, agent) => {
+					return total + Object.keys(agent.subAgents || {}).length;
+				}, 0);
+				console.log(chalk.cyan("\n📊 Project Data Summary:"));
+				console.log(chalk.gray(`  • Agent: ${agentCount}`));
+				console.log(chalk.gray(`  • Tools: ${toolCount}`));
+				console.log(chalk.gray(`  • SubAgent: ${subAgentCount}`));
+				console.log(chalk.green("\n✨ JSON file generated successfully!"));
+				process.exit(0);
+			} catch (error) {
+				s.stop("Failed to generate JSON file");
+				console.error(chalk.red("Error:"), error.message);
+				process.exit(1);
+			}
+		}
+		s.start("Initializing project...");
+		await project.init();
+		const projectId = project.getId();
+		const projectName = project.getName();
+		const stats = project.getStats();
+		s.stop(`Project "${projectName}" (${projectId}) pushed successfully`);
+		console.log(chalk.cyan("\n📊 Project Summary:"));
+		console.log(chalk.gray(`  • Project ID: ${projectId}`));
+		console.log(chalk.gray(`  • Name: ${projectName}`));
+		console.log(chalk.gray(`  • Agent: ${stats.agentCount}`));
+		console.log(chalk.gray(`  • Tenant: ${stats.tenantId}`));
+		const agents = project.getAgents();
+		if (agents.length > 0) {
+			console.log(chalk.cyan("\n📊 Agent Details:"));
+			for (const agent of agents) {
+				const agentStats = agent.getStats();
+				console.log(chalk.gray(`  • ${agent.getName()} (${agent.getId()}): ${agentStats.agentCount} agents`));
+			}
+		}
+		try {
+			const credentialTracking = await project.getCredentialTracking();
+			const credentialCount = Object.keys(credentialTracking.credentials).length;
+			if (credentialCount > 0) {
+				console.log(chalk.cyan("\n🔐 Credentials:"));
+				console.log(chalk.gray(`  • Total credentials: ${credentialCount}`));
+				for (const [credId, credData] of Object.entries(credentialTracking.credentials)) {
+					const usageInfo = credentialTracking.usage[credId] || [];
+					const credType = credData.type || "unknown";
+					const storeId = credData.credentialStoreId || "unknown";
+					console.log(chalk.gray(`  • ${credId} (${credType}, store: ${storeId})`));
+					if (usageInfo.length > 0) {
+						const usageByType = {};
+						for (const usage of usageInfo) usageByType[usage.type] = (usageByType[usage.type] || 0) + 1;
+						const usageSummary = Object.entries(usageByType).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`).join(", ");
+						console.log(chalk.gray(`      Used by: ${usageSummary}`));
+					}
+				}
+			}
+		} catch (_error) {
+			if (env.DEBUG) console.error(chalk.yellow("Could not retrieve credential tracking information"));
+		}
+		if (config.manageUiUrl) {
+			const projectUrl = `${config.manageUiUrl}/${config.tenantId}/projects/${projectId}`;
+			console.log(chalk.cyan("\n🔗 Project URL:"));
+			console.log(chalk.blue.underline(`  ${projectUrl}`));
+		}
+		console.log(chalk.green("\n✨ Next steps:"));
+		console.log(chalk.gray(`  • View all agents: inkeep list-agent`));
+		process.exit(0);
+	} catch (_error) {
+		s.stop("Failed to push project");
+		const error = _error;
+		console.error(chalk.red("Error:"), error.message);
+		if (error.stack && env.DEBUG) console.error(chalk.gray(error.stack));
+		process.exit(1);
+	}
+}
+/**
+* Check if an index.ts file exports a project (has __type = 'project')
+*/
+async function isProjectDirectory(dir) {
+	const indexPath = join(dir, "index.ts");
+	if (!existsSync(indexPath)) return false;
+	try {
+		const { importWithTypeScriptSupport } = await import("../utils/tsx-loader.js");
+		const module = await importWithTypeScriptSupport(indexPath);
+		for (const key of Object.keys(module)) {
+			const value = module[key];
+			if (value && typeof value === "object" && value.__type === "project") return true;
+		}
+		return false;
+	} catch {
+		return false;
+	}
+}
+/**
+* Find all directories containing index.ts that export a project
+*/
+async function findAllProjectDirs(rootDir, excludeDirs = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".temp-validation"
+]) {
+	const projectDirs = [];
+	async function scanDirectory(dir) {
+		if (!existsSync(dir)) return;
+		let items;
+		try {
+			items = readdirSync(dir);
+		} catch {
+			return;
+		}
+		if (existsSync(join(dir, "index.ts"))) {
+			if (await isProjectDirectory(dir)) {
+				projectDirs.push(dir);
+				return;
+			}
+		}
+		for (const item of items) {
+			const fullPath = join(dir, item);
+			if (excludeDirs.includes(item)) continue;
+			try {
+				if (statSync(fullPath).isDirectory()) await scanDirectory(fullPath);
+			} catch {}
+		}
+	}
+	await scanDirectory(rootDir);
+	return projectDirs.sort();
+}
+/**
+* Push all projects found in current directory tree
+*/
+async function pushAllProjects(options) {
+	console.log(chalk.blue("\n🚀 Batch Push: Finding all projects...\n"));
+	const configFiles = findAllConfigFiles(process.cwd(), options.tag);
+	const projectDirsFromConfig = [];
+	for (const configFile of configFiles) {
+		const dir = dirname(configFile);
+		if (existsSync(join(dir, "index.ts"))) projectDirsFromConfig.push(dir);
+	}
+	const allIndexDirs = await findAllProjectDirs(process.cwd());
+	const projectDirsFromIndex = [];
+	for (const dir of allIndexDirs) {
+		if (projectDirsFromConfig.includes(dir)) continue;
+		if (findConfigFile(dir, options.tag)) projectDirsFromIndex.push(dir);
+	}
+	const projectDirs = [...projectDirsFromConfig, ...projectDirsFromIndex].sort();
+	if (projectDirs.length === 0) {
+		const configPattern = options.tag ? `${options.tag}.__inkeep.config.ts__` : "inkeep.config.ts";
+		console.error(chalk.red("No valid projects found."));
+		console.log(chalk.yellow("\nHint: Projects must have an index.ts file and access to an " + configPattern + " file"));
+		console.log(chalk.yellow("      (either in the same directory or in a parent directory)."));
+		process.exit(1);
+	}
+	console.log(chalk.gray(`Found ${projectDirs.length} project(s) to push:\n`));
+	for (const dir of projectDirs) {
+		const relativePath = dir === process.cwd() ? "." : dir.replace(process.cwd() + "/", "");
+		console.log(chalk.gray(`  • ${relativePath}`));
+	}
+	console.log();
+	const results = [];
+	const total = projectDirs.length;
+	for (let i = 0; i < projectDirs.length; i++) {
+		const projectDir = projectDirs[i];
+		const relativePath = projectDir === process.cwd() ? "." : projectDir.replace(process.cwd() + "/", "");
+		const progress = `[${i + 1}/${total}]`;
+		console.log(chalk.cyan(`${progress} Pushing ${relativePath}...`));
+		const result = await pushSingleProject(projectDir, options);
+		results.push(result);
+		if (result.success) console.log(chalk.green(`  ✓ ${result.projectName || result.projectId || basename(projectDir)}`));
+		else console.log(chalk.red(`  ✗ ${basename(projectDir)}: ${result.error}`));
+	}
+	const succeeded = results.filter((r) => r.success).length;
+	const failed = results.filter((r) => !r.success).length;
+	console.log(chalk.cyan("\n📊 Batch Push Summary:"));
+	console.log(chalk.green(`  ✓ Succeeded: ${succeeded}`));
+	if (failed > 0) {
+		console.log(chalk.red(`  ✗ Failed: ${failed}`));
+		console.log(chalk.red("\nFailed projects:"));
+		for (const result of results) if (!result.success) {
+			const relativePath = result.projectDir === process.cwd() ? "." : result.projectDir.replace(process.cwd() + "/", "");
+			console.log(chalk.red(`  • ${relativePath}: ${result.error}`));
+		}
+	}
+	process.exit(failed > 0 ? 1 : 0);
+}
+/**
+* Push a single project (used by batch operations)
+*/
+async function pushSingleProject(projectDir, options) {
+	try {
+		const { config } = await initializeCommand({
+			configPath: findConfigFile(projectDir, options.tag) || void 0,
+			profileName: options.profile,
+			tag: options.tag,
+			showSpinner: false,
+			logConfig: false
+		});
+		const originalTenantId = process.env.INKEEP_TENANT_ID;
+		const originalApiUrl = process.env.INKEEP_API_URL;
+		process.env.INKEEP_TENANT_ID = config.tenantId;
+		process.env.INKEEP_API_URL = config.agentsManageApiUrl;
+		const project = await loadProject(projectDir);
+		if (originalTenantId !== void 0) process.env.INKEEP_TENANT_ID = originalTenantId;
+		else delete process.env.INKEEP_TENANT_ID;
+		if (originalApiUrl !== void 0) process.env.INKEEP_API_URL = originalApiUrl;
+		else delete process.env.INKEEP_API_URL;
+		if (typeof project.setConfig === "function") project.setConfig(config.tenantId, config.agentsManageApiUrl, void 0, config.agentsManageApiKey);
+		if (options.env && typeof project.setCredentials === "function") {
+			const credentials = await loadEnvironmentCredentials(projectDir, options.env);
+			project.setCredentials(credentials);
+		}
+		await project.init();
+		return {
+			projectDir,
+			projectId: project.getId(),
+			projectName: project.getName(),
+			success: true
+		};
+	} catch (error) {
+		return {
+			projectDir,
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
+//#endregion
+export { pushCommand };