@inkeep/agents-cli 0.26.0 → 0.26.2

package/dist/index.js

@@ -5122,7 +5122,7 @@ var require_util = __commonJS({
       return path4;
     }
     exports.normalize = normalize;
-    function join14(aRoot, aPath) {
+    function join15(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -5154,7 +5154,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join14;
+    exports.join = join15;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -5327,7 +5327,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index2 + 1);
           }
         }
-        sourceURL = join14(urlGenerate(parsed), sourceURL);
+        sourceURL = join15(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -226950,11 +226950,11 @@ var init_tools = __esm({
     "use strict";
     init_esm_shims();
     init_context5();
-    init_conversations();
     init_credential_stuffer();
     init_schema();
     init_types();
     init_utils();
+    init_conversations();
     init_logger();
     init_mcp_client();
     init_credentialReferences();
@@ -234741,6 +234741,234 @@ var init_variable_name_registry = __esm({
   }
 });
 
+// src/utils/project-loader.ts
+var project_loader_exports = {};
+__export(project_loader_exports, {
+  loadProject: () => loadProject
+});
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+async function loadProject(projectDir) {
+  const indexPath = join7(projectDir, "index.ts");
+  if (!existsSync7(indexPath)) {
+    throw new Error(`index.ts not found in project directory: ${projectDir}`);
+  }
+  const module = await importWithTypeScriptSupport(indexPath);
+  const exports = Object.keys(module);
+  for (const exportKey of exports) {
+    const value = module[exportKey];
+    if (value && typeof value === "object" && value.__type === "project") {
+      return value;
+    }
+  }
+  throw new Error(
+    'No project export found in index.ts. Expected an export with __type = "project"'
+  );
+}
+var init_project_loader = __esm({
+  "src/utils/project-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tsx_loader();
+  }
+});
+
+// src/utils/json-comparison.ts
+var json_comparison_exports = {};
+__export(json_comparison_exports, {
+  compareProjectDefinitions: () => compareProjectDefinitions
+});
+function compareProjectDefinitions(original, generated) {
+  const differences = [];
+  const warnings = [];
+  const comparePrimitive = (path4, a, b2) => {
+    if (a === b2) return true;
+    if (typeof a !== typeof b2) {
+      differences.push(`Type mismatch at ${path4}: ${typeof a} vs ${typeof b2}`);
+      return false;
+    }
+    if (a !== b2) {
+      differences.push(`Value mismatch at ${path4}: "${a}" vs "${b2}"`);
+      return false;
+    }
+    return true;
+  };
+  const compareArrays = (path4, a, b2) => {
+    if (a.length !== b2.length) {
+      differences.push(`Array length mismatch at ${path4}: ${a.length} vs ${b2.length}`);
+      return false;
+    }
+    let allMatch = true;
+    for (let i2 = 0; i2 < a.length; i2++) {
+      if (!compareValues(`${path4}[${i2}]`, a[i2], b2[i2])) {
+        allMatch = false;
+      }
+    }
+    return allMatch;
+  };
+  const compareObjects = (path4, a, b2) => {
+    const aKeys = Object.keys(a || {}).filter((k2) => !["createdAt", "updatedAt"].includes(k2));
+    const bKeys = Object.keys(b2 || {}).filter((k2) => !["createdAt", "updatedAt"].includes(k2));
+    const missingInB = aKeys.filter((k2) => !bKeys.includes(k2));
+    const extraInB = bKeys.filter((k2) => !aKeys.includes(k2));
+    if (missingInB.length > 0) {
+      differences.push(`Missing keys in generated at ${path4}: ${missingInB.join(", ")}`);
+    }
+    if (extraInB.length > 0) {
+      warnings.push(`Extra keys in generated at ${path4}: ${extraInB.join(", ")}`);
+    }
+    let allMatch = true;
+    for (const key of aKeys) {
+      if (bKeys.includes(key)) {
+        if (!compareValues(`${path4}.${key}`, a[key], b2[key])) {
+          allMatch = false;
+        }
+      }
+    }
+    return allMatch && missingInB.length === 0;
+  };
+  const compareValues = (path4, a, b2) => {
+    if (a === null && b2 === null) return true;
+    if (a === void 0 && b2 === void 0) return true;
+    if ((a === null || a === void 0) !== (b2 === null || b2 === void 0)) {
+      differences.push(`Null/undefined mismatch at ${path4}`);
+      return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b2)) {
+      return compareArrays(path4, a, b2);
+    }
+    if (Array.isArray(a) !== Array.isArray(b2)) {
+      differences.push(`Array type mismatch at ${path4}`);
+      return false;
+    }
+    if (typeof a === "object" && typeof b2 === "object") {
+      return compareObjects(path4, a, b2);
+    }
+    return comparePrimitive(path4, a, b2);
+  };
+  comparePrimitive("id", original.id, generated.id);
+  comparePrimitive("name", original.name, generated.name);
+  if (original.description || generated.description) {
+    const origDesc = original.description || "";
+    const genDesc = generated.description || "";
+    if (origDesc !== genDesc) {
+      comparePrimitive("description", origDesc, genDesc);
+    }
+  }
+  if (original.models || generated.models) {
+    compareValues("models", original.models, generated.models);
+  }
+  if (original.stopWhen || generated.stopWhen) {
+    compareValues("stopWhen", original.stopWhen, generated.stopWhen);
+  }
+  const originalAgentIds = Object.keys(original.agents || {});
+  const generatedAgentIds = Object.keys(generated.agents || {});
+  if (originalAgentIds.length !== generatedAgentIds.length) {
+    differences.push(
+      `Agent count mismatch: ${originalAgentIds.length} vs ${generatedAgentIds.length}`
+    );
+  }
+  for (const agentId of originalAgentIds) {
+    if (!generatedAgentIds.includes(agentId)) {
+      differences.push(`Missing agent in generated: ${agentId}`);
+    } else {
+      compareValues(
+        `agents.${agentId}`,
+        original.agents?.[agentId],
+        generated.agents?.[agentId]
+      );
+    }
+  }
+  for (const agentId of generatedAgentIds) {
+    if (!originalAgentIds.includes(agentId)) {
+      warnings.push(`Extra agent in generated: ${agentId}`);
+    }
+  }
+  const originalToolIds = Object.keys(original.tools || {});
+  const generatedToolIds = Object.keys(generated.tools || {});
+  if (originalToolIds.length !== generatedToolIds.length) {
+    differences.push(`Tool count mismatch: ${originalToolIds.length} vs ${generatedToolIds.length}`);
+  }
+  for (const toolId of originalToolIds) {
+    if (!generatedToolIds.includes(toolId)) {
+      differences.push(`Missing tool in generated: ${toolId}`);
+    } else {
+      compareValues(`tools.${toolId}`, original.tools?.[toolId], generated.tools?.[toolId]);
+    }
+  }
+  if (original.functions || generated.functions) {
+    const originalFunctionIds = Object.keys(original.functions || {});
+    const generatedFunctionIds = Object.keys(generated.functions || {});
+    for (const functionId of originalFunctionIds) {
+      if (!generatedFunctionIds.includes(functionId)) {
+        differences.push(`Missing function in generated: ${functionId}`);
+      } else {
+        compareValues(
+          `functions.${functionId}`,
+          original.functions?.[functionId],
+          generated.functions?.[functionId]
+        );
+      }
+    }
+  }
+  if (original.dataComponents || generated.dataComponents) {
+    const originalComponentIds = Object.keys(original.dataComponents || {});
+    const generatedComponentIds = Object.keys(generated.dataComponents || {});
+    for (const componentId of originalComponentIds) {
+      if (!generatedComponentIds.includes(componentId)) {
+        differences.push(`Missing data component in generated: ${componentId}`);
+      } else {
+        compareValues(
+          `dataComponents.${componentId}`,
+          original.dataComponents?.[componentId],
+          generated.dataComponents?.[componentId]
+        );
+      }
+    }
+  }
+  if (original.artifactComponents || generated.artifactComponents) {
+    const originalArtifactIds = Object.keys(original.artifactComponents || {});
+    const generatedArtifactIds = Object.keys(generated.artifactComponents || {});
+    for (const artifactId of originalArtifactIds) {
+      if (!generatedArtifactIds.includes(artifactId)) {
+        differences.push(`Missing artifact component in generated: ${artifactId}`);
+      } else {
+        compareValues(
+          `artifactComponents.${artifactId}`,
+          original.artifactComponents?.[artifactId],
+          generated.artifactComponents?.[artifactId]
+        );
+      }
+    }
+  }
+  if (original.credentialReferences || generated.credentialReferences) {
+    const originalCredIds = Object.keys(original.credentialReferences || {});
+    const generatedCredIds = Object.keys(generated.credentialReferences || {});
+    for (const credId of originalCredIds) {
+      if (!generatedCredIds.includes(credId)) {
+        differences.push(`Missing credential reference in generated: ${credId}`);
+      } else {
+        const origCred = { ...original.credentialReferences?.[credId] || {} };
+        const genCred = { ...generated.credentialReferences?.[credId] || {} };
+        delete origCred.usedBy;
+        delete genCred.usedBy;
+        compareValues(`credentialReferences.${credId}`, origCred, genCred);
+      }
+    }
+  }
+  return {
+    matches: differences.length === 0,
+    differences,
+    warnings
+  };
+}
+var init_json_comparison = __esm({
+  "src/utils/json-comparison.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/commands/pull.placeholder-system.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { jsonSchemaToZod } from "json-schema-to-zod";
@@ -234955,7 +235183,7 @@ __export(pull_llm_generate_exports, {
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { anthropic, createAnthropic } from "@ai-sdk/anthropic";
 import { google } from "@ai-sdk/google";
 import { createOpenAI, openai } from "@ai-sdk/openai";
@@ -234963,8 +235191,8 @@ import { generateText } from "ai";
 function getTypeDefinitions() {
   try {
     const sdkPackagePath = require3.resolve("@inkeep/agents-sdk/package.json");
-    const sdkPackageDir = join7(sdkPackagePath, "..");
-    const sdkDtsPath = join7(sdkPackageDir, "dist/index.d.ts");
+    const sdkPackageDir = join8(sdkPackagePath, "..");
+    const sdkDtsPath = join8(sdkPackageDir, "dist/index.d.ts");
     const dtsContent = readFileSync3(sdkDtsPath, "utf-8");
     return `
 TYPESCRIPT TYPE DEFINITIONS (from @inkeep/agents-sdk):
@@ -235834,7 +236062,7 @@ Generate ONLY the TypeScript code without any markdown or explanations.`;
 }
 function generateEnvironmentFileTemplate(environmentsDir, environment, credentials) {
   const { writeFileSync: writeFileSync7 } = require3("node:fs");
-  const { join: join14 } = require3("node:path");
+  const { join: join15 } = require3("node:path");
   let credentialsCode = "";
   const hasCredentials = credentials && Object.keys(credentials).length > 0;
   if (hasCredentials) {
@@ -235871,15 +236099,15 @@ export const ${environment} = registerEnvironmentSettings({
   credentials: {${credentialsCode}}
 });
 `;
-  writeFileSync7(join14(environmentsDir, `${environment}.env.ts`), envContent);
+  writeFileSync7(join15(environmentsDir, `${environment}.env.ts`), envContent);
   updateEnvironmentIndexTemplate(environmentsDir, environment);
 }
 function updateEnvironmentIndexTemplate(environmentsDir, newEnvironment) {
-  const { writeFileSync: writeFileSync7, existsSync: existsSync12, readFileSync: readFileSync8 } = require3("node:fs");
-  const { join: join14 } = require3("node:path");
-  const indexPath = join14(environmentsDir, "index.ts");
+  const { writeFileSync: writeFileSync7, existsSync: existsSync13, readFileSync: readFileSync8 } = require3("node:fs");
+  const { join: join15 } = require3("node:path");
+  const indexPath = join15(environmentsDir, "index.ts");
   const existingEnvironments = [];
-  if (existsSync12(indexPath)) {
+  if (existsSync13(indexPath)) {
     const existingContent = readFileSync8(indexPath, "utf-8");
     const importRegex = /import\s+{\s*(\w+)\s*}\s+from\s+['"]\.\/([\w-]+)\.env['"];?/g;
     let match2;
@@ -235943,15 +236171,15 @@ export const ${environment} = registerEnvironmentSettings({
   credentials: {${credentialsCode}}
 });
 `;
-  writeFileSync3(join7(environmentsDir, `${environment}.env.ts`), envContent);
+  writeFileSync3(join8(environmentsDir, `${environment}.env.ts`), envContent);
   await updateEnvironmentIndex(environmentsDir, environment);
 }
 async function updateEnvironmentIndex(environmentsDir, environment) {
-  const indexPath = join7(environmentsDir, "index.ts");
-  const { readFileSync: readFileSync8, existsSync: existsSync12 } = await import("fs");
+  const indexPath = join8(environmentsDir, "index.ts");
+  const { readFileSync: readFileSync8, existsSync: existsSync13 } = await import("fs");
   const existingEnvironments = [];
   let existingContent = "";
-  if (existsSync12(indexPath)) {
+  if (existsSync13(indexPath)) {
     existingContent = readFileSync8(indexPath, "utf-8");
     const importRegex = /import\s+{\s*(\w+)\s*}\s+from\s+['"]\.\/([\w-]+)\.env['"];?/g;
     let match2;
@@ -236596,11 +236824,11 @@ var pattern_analyzer_exports = {};
 __export(pattern_analyzer_exports, {
   analyzeExistingPatterns: () => analyzeExistingPatterns
 });
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
+import { join as join9 } from "path";
 async function analyzeExistingPatterns(projectDir) {
-  const indexPath = join8(projectDir, "index.ts");
-  if (!existsSync7(indexPath)) {
+  const indexPath = join9(projectDir, "index.ts");
+  if (!existsSync8(indexPath)) {
     return null;
   }
   const fileStructure = analyzeFileStructure(projectDir);
@@ -236622,17 +236850,17 @@ async function analyzeExistingPatterns(projectDir) {
   };
 }
 function analyzeFileStructure(projectDir) {
-  const hasAgentsDirectory = existsSync7(join8(projectDir, "agents"));
-  const hasToolsDirectory = existsSync7(join8(projectDir, "tools"));
-  const hasDataComponentsDirectory = existsSync7(join8(projectDir, "data-components"));
-  const hasArtifactComponentsDirectory = existsSync7(join8(projectDir, "artifact-components"));
-  const hasEnvironmentsDirectory = existsSync7(join8(projectDir, "environments"));
-  const hasExternalAgentsDirectory = existsSync7(join8(projectDir, "external-agents"));
+  const hasAgentsDirectory = existsSync8(join9(projectDir, "agents"));
+  const hasToolsDirectory = existsSync8(join9(projectDir, "tools"));
+  const hasDataComponentsDirectory = existsSync8(join9(projectDir, "data-components"));
+  const hasArtifactComponentsDirectory = existsSync8(join9(projectDir, "artifact-components"));
+  const hasEnvironmentsDirectory = existsSync8(join9(projectDir, "environments"));
+  const hasExternalAgentsDirectory = existsSync8(join9(projectDir, "external-agents"));
   let toolsLocation = "unknown";
   if (hasToolsDirectory) {
     toolsLocation = "separate";
   } else if (hasAgentsDirectory) {
-    const agentFiles = getFilesInDirectory(join8(projectDir, "agents"), ".ts");
+    const agentFiles = getFilesInDirectory(join9(projectDir, "agents"), ".ts");
     const hasInlineTools = agentFiles.some((file) => {
       const content = readFileSync4(file, "utf-8");
       return content.includes("functionTool(");
@@ -236642,8 +236870,8 @@ function analyzeFileStructure(projectDir) {
   const agentsLocation = hasAgentsDirectory ? "flat" : "unknown";
   const allFiles = [
     ...getFilesInDirectory(projectDir, ".ts"),
-    ...hasAgentsDirectory ? getFilesInDirectory(join8(projectDir, "agents"), ".ts") : [],
-    ...hasToolsDirectory ? getFilesInDirectory(join8(projectDir, "tools"), ".ts") : []
+    ...hasAgentsDirectory ? getFilesInDirectory(join9(projectDir, "agents"), ".ts") : [],
+    ...hasToolsDirectory ? getFilesInDirectory(join9(projectDir, "tools"), ".ts") : []
   ];
   const preferredFileNaming = detectFileNamingConvention(allFiles);
   return {
@@ -236689,7 +236917,7 @@ function collectCodeExamples(projectDir, fileStructure) {
     mappings: []
   };
   if (fileStructure.hasAgentsDirectory) {
-    const agentDir = join8(projectDir, "agents");
+    const agentDir = join9(projectDir, "agents");
     const agentFiles = getFilesInDirectory(agentDir, ".ts");
     for (const file of agentFiles.slice(0, 3)) {
       const content = readFileSync4(file, "utf-8");
@@ -236701,7 +236929,7 @@ function collectCodeExamples(projectDir, fileStructure) {
     }
   }
   if (fileStructure.hasToolsDirectory) {
-    const toolsDir = join8(projectDir, "tools");
+    const toolsDir = join9(projectDir, "tools");
     const toolFiles = getFilesInDirectory(toolsDir, ".ts");
     for (const file of toolFiles.slice(0, 3)) {
       const content = readFileSync4(file, "utf-8");
@@ -236710,8 +236938,8 @@ function collectCodeExamples(projectDir, fileStructure) {
       examples.mappings.push(...mappings);
     }
   }
-  const indexPath = join8(projectDir, "index.ts");
-  if (existsSync7(indexPath)) {
+  const indexPath = join9(projectDir, "index.ts");
+  if (existsSync8(indexPath)) {
     const content = readFileSync4(indexPath, "utf-8");
     const imports = extractImports(content);
     examples.imports.push(...imports);
@@ -236842,13 +237070,13 @@ function mostCommon(arr) {
   return mostCommonItem;
 }
 function getFilesInDirectory(dir, extension) {
-  if (!existsSync7(dir)) {
+  if (!existsSync8(dir)) {
     return [];
   }
   const files = [];
   const entries = readdirSync2(dir);
   for (const entry of entries) {
-    const fullPath = join8(dir, entry);
+    const fullPath = join9(dir, entry);
     const stat = statSync(fullPath);
     if (stat.isDirectory()) {
       files.push(...getFilesInDirectory(fullPath, extension));
@@ -237898,11 +238126,11 @@ __export(plan_storage_exports, {
   planExists: () => planExists,
   savePlan: () => savePlan
 });
-import { existsSync as existsSync8, mkdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, mkdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join10 } from "path";
 function savePlan(projectRoot, plan) {
-  const inkeepDir = join9(projectRoot, ".inkeep");
-  if (!existsSync8(inkeepDir)) {
+  const inkeepDir = join10(projectRoot, ".inkeep");
+  if (!existsSync9(inkeepDir)) {
     mkdirSync(inkeepDir, { recursive: true });
   }
   const gitCommit = getGitCommit(projectRoot);
@@ -237915,15 +238143,15 @@ function savePlan(projectRoot, plan) {
     },
     plan
   };
-  const planPath = join9(inkeepDir, "generation-plan.json");
+  const planPath = join10(inkeepDir, "generation-plan.json");
   writeFileSync5(planPath, JSON.stringify(storedPlan, null, 2));
-  const backupPath = join9(inkeepDir, `generation-plan-${Date.now()}.json`);
+  const backupPath = join10(inkeepDir, `generation-plan-${Date.now()}.json`);
   writeFileSync5(backupPath, JSON.stringify(storedPlan, null, 2));
   cleanupOldBackups(inkeepDir);
 }
 function loadPlan(projectRoot) {
-  const planPath = join9(projectRoot, ".inkeep", "generation-plan.json");
-  if (!existsSync8(planPath)) {
+  const planPath = join10(projectRoot, ".inkeep", "generation-plan.json");
+  if (!existsSync9(planPath)) {
     return null;
   }
   try {
@@ -237935,8 +238163,8 @@ function loadPlan(projectRoot) {
   }
 }
 function planExists(projectRoot) {
-  const planPath = join9(projectRoot, ".inkeep", "generation-plan.json");
-  return existsSync8(planPath);
+  const planPath = join10(projectRoot, ".inkeep", "generation-plan.json");
+  return existsSync9(planPath);
 }
 function getGitCommit(projectRoot) {
   try {
@@ -237955,8 +238183,8 @@ function cleanupOldBackups(inkeepDir) {
     const { readdirSync: readdirSync3, unlinkSync, statSync: statSync2 } = __require("fs");
     const files = readdirSync3(inkeepDir).filter((f) => f.startsWith("generation-plan-") && f.endsWith(".json")).map((f) => ({
       name: f,
-      path: join9(inkeepDir, f),
-      mtime: statSync2(join9(inkeepDir, f)).mtime.getTime()
+      path: join10(inkeepDir, f),
+      mtime: statSync2(join10(inkeepDir, f)).mtime.getTime()
     })).sort((a, b2) => b2.mtime - a.mtime);
     for (let i2 = 5; i2 < files.length; i2++) {
       unlinkSync(files[i2].path);
@@ -238065,9 +238293,9 @@ function displayPlanDiff(diff) {
   }
 }
 function ensureGitignore(projectRoot) {
-  const gitignorePath = join9(projectRoot, ".gitignore");
+  const gitignorePath = join10(projectRoot, ".gitignore");
   let content = "";
-  if (existsSync8(gitignorePath)) {
+  if (existsSync9(gitignorePath)) {
     content = readFileSync5(gitignorePath, "utf-8");
   }
   if (content.includes(".inkeep")) {
@@ -238088,7 +238316,7 @@ init_esm_shims();
 init_env2();
 init_instrumentation();
 import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
+import { dirname as dirname6, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 
@@ -239202,8 +239430,8 @@ ${table.toString()}`);
 
 // src/commands/pull.ts
 init_esm_shims();
-import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname5, join as join10, resolve as resolve4 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join11, resolve as resolve4 } from "path";
 import * as p7 from "@clack/prompts";
 import chalk9 from "chalk";
 init_variable_name_registry();
@@ -239333,14 +239561,14 @@ async function findProjectDirectory(projectId, configPath) {
 // src/commands/pull.ts
 init_tsx_loader();
 async function detectCurrentProject(debug = false) {
-  const indexPath = join10(process.cwd(), "index.ts");
+  const indexPath = join11(process.cwd(), "index.ts");
   if (debug) {
     console.log(chalk9.gray(`
 [DEBUG] Detecting project in current directory...`));
     console.log(chalk9.gray(`  \u2022 Current directory: ${process.cwd()}`));
     console.log(chalk9.gray(`  \u2022 Looking for: ${indexPath}`));
   }
-  if (!existsSync9(indexPath)) {
+  if (!existsSync10(indexPath)) {
     if (debug) {
       console.log(chalk9.gray(`  \u2022 index.ts not found`));
     }
@@ -239405,8 +239633,8 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
   const errors = [];
   const warnings = [];
   try {
-    const indexPath = join10(projectDir, "index.ts");
-    if (!existsSync9(indexPath)) {
+    const indexPath = join11(projectDir, "index.ts");
+    if (!existsSync10(indexPath)) {
       errors.push("Generated index.ts file not found");
       return { success: false, errors, warnings };
     }
@@ -239429,35 +239657,35 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
     } else {
       warnings.push("Could not extract project ID from index.ts");
     }
-    const agentsDir = join10(projectDir, "agents");
+    const agentsDir = join11(projectDir, "agents");
     const expectedAgents = Object.keys(originalProjectData.agents || {});
     for (const agentId of expectedAgents) {
       const kebabCaseId = agentId.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-      const agentPath = join10(agentsDir, `${kebabCaseId}.ts`);
-      if (!existsSync9(agentPath)) {
+      const agentPath = join11(agentsDir, `${kebabCaseId}.ts`);
+      if (!existsSync10(agentPath)) {
         errors.push(`Agent file not found: agents/${kebabCaseId}.ts`);
       } else if (debug) {
         console.log(chalk9.gray(`  \u2713 Agent file exists: agents/${kebabCaseId}.ts`));
       }
     }
-    const toolsDir = join10(projectDir, "tools");
+    const toolsDir = join11(projectDir, "tools");
     const expectedTools = Object.entries(originalProjectData.tools || {});
     const filenameGenerator = new VariableNameGenerator(DEFAULT_NAMING_CONVENTIONS);
     for (const [toolId, toolData] of expectedTools) {
       const fileName = filenameGenerator.generateFileName(toolId, "tool", toolData);
-      const toolPath = join10(toolsDir, `${fileName}.ts`);
-      if (!existsSync9(toolPath)) {
+      const toolPath = join11(toolsDir, `${fileName}.ts`);
+      if (!existsSync10(toolPath)) {
         errors.push(`Tool file not found: tools/${fileName}.ts`);
       } else if (debug) {
         console.log(chalk9.gray(`  \u2713 Tool file exists: tools/${fileName}.ts`));
       }
     }
-    const dataComponentsDir = join10(projectDir, "data-components");
+    const dataComponentsDir = join11(projectDir, "data-components");
     const expectedDataComponents = Object.keys(originalProjectData.dataComponents || {});
     for (const componentId of expectedDataComponents) {
       const kebabCaseId = componentId.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-      const componentPath = join10(dataComponentsDir, `${kebabCaseId}.ts`);
-      if (!existsSync9(componentPath)) {
+      const componentPath = join11(dataComponentsDir, `${kebabCaseId}.ts`);
+      if (!existsSync10(componentPath)) {
         errors.push(`Data component file not found: data-components/${kebabCaseId}.ts`);
       } else if (debug) {
         console.log(
@@ -239465,17 +239693,17 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
         );
       }
     }
-    const environmentsDir = join10(projectDir, "environments");
+    const environmentsDir = join11(projectDir, "environments");
     const hasCredentials = Object.keys(originalProjectData.credentialReferences || {}).length > 0;
-    if (!existsSync9(environmentsDir)) {
+    if (!existsSync10(environmentsDir)) {
       if (hasCredentials) {
         errors.push("Environments directory not found (expected with credentials)");
       } else {
         warnings.push("Environments directory not found (no credentials defined)");
       }
     } else {
-      const envIndexPath = join10(environmentsDir, "index.ts");
-      if (!existsSync9(envIndexPath)) {
+      const envIndexPath = join11(environmentsDir, "index.ts");
+      if (!existsSync10(envIndexPath)) {
         if (hasCredentials) {
           errors.push("Environment index.ts not found (expected with credentials)");
         } else {
@@ -239487,7 +239715,7 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
     }
     if (debug) {
       console.log(chalk9.gray("\n\u{1F50D} Verification Summary:"));
-      console.log(chalk9.gray(`  \u2022 index.ts: ${existsSync9(indexPath) ? "\u2713" : "\u2717"}`));
+      console.log(chalk9.gray(`  \u2022 index.ts: ${existsSync10(indexPath) ? "\u2713" : "\u2717"}`));
       console.log(
         chalk9.gray(`  \u2022 Agent files: ${expectedAgents.length}/${expectedAgents.length} found`)
       );
@@ -239506,9 +239734,87 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
     return { success: false, errors, warnings };
   }
 }
+async function roundTripValidation(projectDir, originalProjectData, config, debug = false) {
+  const errors = [];
+  const warnings = [];
+  try {
+    if (debug) {
+      console.log(chalk9.gray("\n[DEBUG] Starting round-trip validation..."));
+      console.log(chalk9.gray(`  \u2022 Loading project from: ${projectDir}`));
+    }
+    const { loadProject: loadProject2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
+    const { compareProjectDefinitions: compareProjectDefinitions2 } = await Promise.resolve().then(() => (init_json_comparison(), json_comparison_exports));
+    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;
+    let project;
+    try {
+      project = await loadProject2(projectDir);
+      if (debug) {
+        console.log(chalk9.gray(`  \u2022 Project loaded successfully: ${project.getId()}`));
+      }
+    } catch (loadError) {
+      errors.push(`Failed to load generated project: ${loadError.message}`);
+      return { success: false, errors, warnings };
+    } finally {
+      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,
+        // models - come from project definition
+        config.agentsManageApiKey
+      );
+    }
+    let generatedDefinition;
+    try {
+      generatedDefinition = await project.getFullDefinition();
+      if (debug) {
+        console.log(chalk9.gray(`  \u2022 Generated definition serialized successfully`));
+        console.log(chalk9.gray(`    - Agents: ${Object.keys(generatedDefinition.agents || {}).length}`));
+        console.log(chalk9.gray(`    - Tools: ${Object.keys(generatedDefinition.tools || {}).length}`));
+      }
+    } catch (serializeError) {
+      errors.push(`Failed to serialize generated project: ${serializeError.message}`);
+      return { success: false, errors, warnings };
+    }
+    const comparisonResult = compareProjectDefinitions2(originalProjectData, generatedDefinition);
+    if (debug) {
+      console.log(chalk9.gray(`  \u2022 Comparison complete:`));
+      console.log(chalk9.gray(`    - Matches: ${comparisonResult.matches}`));
+      console.log(chalk9.gray(`    - Differences: ${comparisonResult.differences.length}`));
+      console.log(chalk9.gray(`    - Warnings: ${comparisonResult.warnings.length}`));
+    }
+    errors.push(...comparisonResult.differences);
+    warnings.push(...comparisonResult.warnings);
+    return {
+      success: comparisonResult.matches && errors.length === 0,
+      errors,
+      warnings
+    };
+  } catch (error) {
+    errors.push(`Round-trip validation failed: ${error.message}`);
+    if (debug) {
+      console.log(chalk9.red(`[DEBUG] Round-trip validation error: ${error.stack}`));
+    }
+    return { success: false, errors, warnings };
+  }
+}
 async function loadProjectConfig(projectDir, configPathOverride) {
-  const configPath = configPathOverride ? resolve4(process.cwd(), configPathOverride) : join10(projectDir, "inkeep.config.ts");
-  if (!existsSync9(configPath)) {
+  const configPath = configPathOverride ? resolve4(process.cwd(), configPathOverride) : join11(projectDir, "inkeep.config.ts");
+  if (!existsSync10(configPath)) {
     throw new Error(`Configuration file not found: ${configPath}`);
   }
   try {
@@ -239533,7 +239839,7 @@ async function loadProjectConfig(projectDir, configPathOverride) {
   }
 }
 function ensureDirectoryExists(dirPath) {
-  if (!existsSync9(dirPath)) {
+  if (!existsSync10(dirPath)) {
     mkdirSync2(dirPath, { recursive: true });
   }
 }
@@ -239543,15 +239849,15 @@ function createProjectStructure(projectDir, projectId, useCurrentDirectory = fal
     projectRoot = projectDir;
   } else {
     const dirName = projectDir.split("/").pop() || projectDir;
-    projectRoot = dirName === projectId ? projectDir : join10(projectDir, projectId);
-  }
-  const agentsDir = join10(projectRoot, "agents");
-  const toolsDir = join10(projectRoot, "tools");
-  const dataComponentsDir = join10(projectRoot, "data-components");
-  const artifactComponentsDir = join10(projectRoot, "artifact-components");
-  const statusComponentsDir = join10(projectRoot, "status-components");
-  const environmentsDir = join10(projectRoot, "environments");
-  const externalAgentsDir = join10(projectRoot, "external-agents");
+    projectRoot = dirName === projectId ? projectDir : join11(projectDir, projectId);
+  }
+  const agentsDir = join11(projectRoot, "agents");
+  const toolsDir = join11(projectRoot, "tools");
+  const dataComponentsDir = join11(projectRoot, "data-components");
+  const artifactComponentsDir = join11(projectRoot, "artifact-components");
+  const statusComponentsDir = join11(projectRoot, "status-components");
+  const environmentsDir = join11(projectRoot, "environments");
+  const externalAgentsDir = join11(projectRoot, "external-agents");
   ensureDirectoryExists(projectRoot);
   ensureDirectoryExists(agentsDir);
   ensureDirectoryExists(toolsDir);
@@ -239610,7 +239916,7 @@ async function pullProjectCommand(options) {
     const searchDir = process.cwd();
     if (options.config) {
       const configPath = resolve4(process.cwd(), options.config);
-      if (existsSync9(configPath)) {
+      if (existsSync10(configPath)) {
         try {
           config = await loadProjectConfig(dirname5(configPath), options.config);
           configFound = true;
@@ -239628,8 +239934,8 @@ async function pullProjectCommand(options) {
       }
     }
     if (!configFound) {
-      const currentConfigPath = join10(searchDir, "inkeep.config.ts");
-      if (existsSync9(currentConfigPath)) {
+      const currentConfigPath = join11(searchDir, "inkeep.config.ts");
+      if (existsSync10(currentConfigPath)) {
         try {
           config = await loadProjectConfig(searchDir);
           configFound = true;
@@ -239639,10 +239945,10 @@ async function pullProjectCommand(options) {
         }
       }
       if (!configFound) {
-        const parentConfigPath = join10(searchDir, "..", "inkeep.config.ts");
-        if (existsSync9(parentConfigPath)) {
+        const parentConfigPath = join11(searchDir, "..", "inkeep.config.ts");
+        if (existsSync10(parentConfigPath)) {
           try {
-            config = await loadProjectConfig(join10(searchDir, ".."));
+            config = await loadProjectConfig(join11(searchDir, ".."));
             configFound = true;
             configLocation = parentConfigPath;
           } catch (_error) {
@@ -239672,7 +239978,7 @@ async function pullProjectCommand(options) {
       );
       console.log(chalk9.gray("Searched in:"));
       console.log(chalk9.gray(`  \u2022 Current directory: ${searchDir}`));
-      console.log(chalk9.gray(`  \u2022 Parent directory: ${join10(searchDir, "..")}`));
+      console.log(chalk9.gray(`  \u2022 Parent directory: ${join11(searchDir, "..")}`));
       console.log(chalk9.gray(`  \u2022 Parent directories up to root`));
       process.exit(1);
     }
@@ -239686,8 +239992,8 @@ async function pullProjectCommand(options) {
     } else {
       const projectRoot = await findProjectDirectory();
       if (projectRoot) {
-        const srcPath = join10(projectRoot, "src");
-        baseDir = existsSync9(srcPath) ? srcPath : projectRoot;
+        const srcPath = join11(projectRoot, "src");
+        baseDir = existsSync10(srcPath) ? srcPath : projectRoot;
       } else {
         baseDir = process.cwd();
       }
@@ -239822,7 +240128,7 @@ async function pullProjectCommand(options) {
     const dirs = createProjectStructure(baseDir, finalConfig.projectId, useCurrentDirectory);
     s2.stop("Project structure created");
     if (options.json) {
-      const jsonFilePath = join10(dirs.projectRoot, `${finalConfig.projectId}.json`);
+      const jsonFilePath = join11(dirs.projectRoot, `${finalConfig.projectId}.json`);
       writeFileSync6(jsonFilePath, JSON.stringify(projectData, null, 2));
       s2.stop(`Project data saved to ${jsonFilePath}`);
       console.log(chalk9.green(`\u2705 JSON file created: ${jsonFilePath}`));
@@ -239943,11 +240249,63 @@ async function pullProjectCommand(options) {
       if (verificationResult.success) {
         s2.stop("Generated files verified successfully");
         if (options.debug && verificationResult.warnings.length > 0) {
-          console.log(chalk9.yellow("\n\u26A0\uFE0F  Verification warnings:"));
+          console.log(chalk9.yellow("\n\u26A0\uFE0F  File verification warnings:"));
           verificationResult.warnings.forEach((warning) => {
             console.log(chalk9.gray(`  \u2022 ${warning}`));
           });
         }
+        s2.start("Performing round-trip validation...");
+        try {
+          const roundTripResult = await roundTripValidation(
+            dirs.projectRoot,
+            projectData,
+            {
+              tenantId: finalConfig.tenantId,
+              agentsManageApiUrl: finalConfig.agentsManageApiUrl,
+              agentsManageApiKey: finalConfig.agentsManageApiKey
+            },
+            options.debug || false
+          );
+          if (roundTripResult.success) {
+            s2.stop("Round-trip validation passed - generated TS matches backend data");
+            if (options.debug && roundTripResult.warnings.length > 0) {
+              console.log(chalk9.yellow("\n\u26A0\uFE0F  Round-trip validation warnings:"));
+              roundTripResult.warnings.forEach((warning) => {
+                console.log(chalk9.gray(`  \u2022 ${warning}`));
+              });
+            }
+          } else {
+            s2.stop("Round-trip validation failed");
+            console.error(chalk9.red("\n\u274C Round-trip validation errors:"));
+            console.error(
+              chalk9.gray(
+                "   The generated TypeScript does not serialize back to match the original backend data."
+              )
+            );
+            roundTripResult.errors.forEach((error) => {
+              console.error(chalk9.red(`  \u2022 ${error}`));
+            });
+            if (roundTripResult.warnings.length > 0) {
+              console.log(chalk9.yellow("\n\u26A0\uFE0F  Round-trip validation warnings:"));
+              roundTripResult.warnings.forEach((warning) => {
+                console.log(chalk9.gray(`  \u2022 ${warning}`));
+              });
+            }
+            console.log(
+              chalk9.yellow(
+                "\n\u26A0\uFE0F  This indicates an issue with LLM generation or schema mappings."
+              )
+            );
+            console.log(chalk9.gray("The generated files may not work correctly with `inkeep push`."));
+          }
+        } catch (roundTripError) {
+          s2.stop("Round-trip validation could not be completed");
+          console.error(chalk9.yellow(`
+Round-trip validation error: ${roundTripError.message}`));
+          if (options.debug && roundTripError.stack) {
+            console.error(chalk9.gray(roundTripError.stack));
+          }
+        }
       } else {
         s2.stop("Generated files verification failed");
         console.error(chalk9.red("\n\u274C Verification errors:"));
@@ -239955,7 +240313,7 @@ async function pullProjectCommand(options) {
           console.error(chalk9.red(`  \u2022 ${error}`));
         });
         if (verificationResult.warnings.length > 0) {
-          console.log(chalk9.yellow("\n\u26A0\uFE0F  Verification warnings:"));
+          console.log(chalk9.yellow("\n\u26A0\uFE0F  File verification warnings:"));
           verificationResult.warnings.forEach((warning) => {
             console.log(chalk9.gray(`  \u2022 ${warning}`));
           });
@@ -240012,20 +240370,20 @@ async function pullProjectCommand(options) {
 // src/commands/push.ts
 init_esm_shims();
 init_env2();
-import { existsSync as existsSync11 } from "fs";
-import { join as join12, resolve as resolve5 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join13, resolve as resolve5 } from "path";
 import chalk10 from "chalk";
 import * as p8 from "@clack/prompts";
 
 // src/utils/environment-loader.ts
 init_esm_shims();
 init_tsx_loader();
-import { existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 async function loadEnvironmentCredentials(projectDir, env3) {
-  const environmentsDir = join11(projectDir, "environments");
-  const envFilePath = join11(environmentsDir, `${env3}.env.ts`);
-  if (!existsSync10(envFilePath)) {
+  const environmentsDir = join12(projectDir, "environments");
+  const envFilePath = join12(environmentsDir, `${env3}.env.ts`);
+  if (!existsSync11(envFilePath)) {
     throw new Error(
       `Environment file not found: ${envFilePath}
 Make sure you have a ${env3}.env.ts file in the environments directory.`
@@ -240051,24 +240409,7 @@ Make sure you have a ${env3}.env.ts file in the environments directory.`
 }
 
 // src/commands/push.ts
-init_tsx_loader();
-async function loadProject(projectDir) {
-  const indexPath = join12(projectDir, "index.ts");
-  if (!existsSync11(indexPath)) {
-    throw new Error(`index.ts not found in project directory: ${projectDir}`);
-  }
-  const module = await importWithTypeScriptSupport(indexPath);
-  const exports = Object.keys(module);
-  for (const exportKey of exports) {
-    const value = module[exportKey];
-    if (value && typeof value === "object" && value.__type === "project") {
-      return value;
-    }
-  }
-  throw new Error(
-    'No project export found in index.ts. Expected an export with __type = "project"'
-  );
-}
+init_project_loader();
 async function pushCommand(options) {
   performBackgroundVersionCheck();
   const { config } = await initializeCommand({
@@ -240083,13 +240424,13 @@ async function pushCommand(options) {
     let projectDir;
     if (options.project) {
       projectDir = resolve5(process.cwd(), options.project);
-      if (!existsSync11(join12(projectDir, "index.ts"))) {
+      if (!existsSync12(join13(projectDir, "index.ts"))) {
         s2.stop(`No index.ts found in specified project directory: ${projectDir}`);
         process.exit(1);
       }
     } else {
       const currentDir = process.cwd();
-      if (existsSync11(join12(currentDir, "index.ts"))) {
+      if (existsSync12(join13(currentDir, "index.ts"))) {
         projectDir = currentDir;
       } else {
         s2.stop("No index.ts found in current directory");
@@ -240150,7 +240491,7 @@ async function pushCommand(options) {
       s2.start("Generating project data JSON...");
       try {
         const projectDefinition = await project.getFullDefinition();
-        const jsonFilePath = join12(projectDir, `project.json`);
+        const jsonFilePath = join13(projectDir, `project.json`);
         const fs5 = await import("fs/promises");
         await fs5.writeFile(jsonFilePath, JSON.stringify(projectDefinition, null, 2));
         s2.stop(`Project data saved to ${jsonFilePath}`);
@@ -240386,7 +240727,7 @@ async function updateCommand(options = {}) {
 // src/index.ts
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname6(__filename3);
-var packageJsonPath = join13(__dirname3, "..", "package.json");
+var packageJsonPath = join14(__dirname3, "..", "package.json");
 var packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
 var program = new Command();
 program.name("inkeep").description("CLI tool for Inkeep Agent Framework").version(packageJson.version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-cli",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "description": "Inkeep CLI tool",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,8 +48,8 @@
     "recast": "^0.23.0",
     "ts-morph": "^26.0.0",
     "tsx": "^4.20.5",
-    "@inkeep/agents-core": "^0.26.0",
-    "@inkeep/agents-sdk": "^0.26.0"
+    "@inkeep/agents-core": "^0.26.2",
+    "@inkeep/agents-sdk": "^0.26.2"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",