@inkeep/agents-cli 0.22.5 → 0.22.7

package/dist/index.js

@@ -234489,10 +234489,13 @@ function generateMultiPlaceholderString(value, jsonPath, tracker) {
   }
   return value;
 }
-function isJsonSchemaPath(path4) {
+function isJsonSchemaPath(path4, context) {
   if (path4.endsWith("contextConfig.headersSchema") || path4.endsWith("responseSchema")) {
     return true;
   }
+  if (path4.endsWith("headersSchema") && path4.length > "headersSchema".length) {
+    return true;
+  }
   if (path4.includes("artifactComponents") && path4.endsWith("props")) {
     return true;
   }
@@ -234502,13 +234505,29 @@ function isJsonSchemaPath(path4) {
   if (path4.includes("statusComponents") && path4.endsWith("detailsSchema")) {
     return true;
   }
+  if (path4.endsWith("inputSchema") || path4.endsWith("outputSchema")) {
+    return true;
+  }
+  if (context?.fileType) {
+    if (path4 === "props" && (context.fileType === "dataComponent" || context.fileType === "artifactComponent")) {
+      return true;
+    }
+    if (path4 === "detailsSchema" && context.fileType === "statusComponent") {
+      return true;
+    }
+    if (context.fileType === "contextConfig") {
+      if (path4 === "headersSchema" || path4.endsWith("responseSchema")) {
+        return true;
+      }
+    }
+  }
   return false;
 }
 function updateTracker(tracker, placeholder, value) {
   tracker.placeholderToValue.set(placeholder, value);
   tracker.valueToPlaceholder.set(value, placeholder);
 }
-function processObject(obj, tracker, path4 = "") {
+function processObject(obj, tracker, path4 = "", context) {
   if (typeof obj === "string") {
     if (containsTemplateLiterals(obj)) {
       return generateMultiPlaceholderString(obj, path4, tracker);
@@ -234531,7 +234550,7 @@ function processObject(obj, tracker, path4 = "") {
     }
     return obj;
   }
-  if (isJsonSchemaPath(path4)) {
+  if (isJsonSchemaPath(path4, context)) {
     try {
       const zodSchema = jsonSchemaToZod(obj);
       return zodSchema;
@@ -234540,25 +234559,25 @@ function processObject(obj, tracker, path4 = "") {
     }
   }
   if (Array.isArray(obj)) {
-    return obj.map((item, index2) => processObject(item, tracker, `${path4}[${index2}]`));
+    return obj.map((item, index2) => processObject(item, tracker, `${path4}[${index2}]`, context));
   }
   if (obj && typeof obj === "object") {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
       const currentPath = path4 ? `${path4}.${key}` : key;
-      result[key] = processObject(value, tracker, currentPath);
+      result[key] = processObject(value, tracker, currentPath, context);
     }
     return result;
   }
   return obj;
 }
-function createPlaceholders(data) {
+function createPlaceholders(data, context) {
   const tracker = {
     placeholderToValue: /* @__PURE__ */ new Map(),
     valueToPlaceholder: /* @__PURE__ */ new Map()
   };
   try {
-    const processedData = processObject(data, tracker);
+    const processedData = processObject(data, tracker, "", context);
     const replacements = {};
     for (const [placeholder, value] of tracker.placeholderToValue.entries()) {
       replacements[placeholder] = value;
@@ -234681,8 +234700,8 @@ function createModel(config) {
 function cleanGeneratedCode(text2) {
   return text2.replace(/^```(?:typescript|ts)?\n?/, "").replace(/\n?```$/, "").trim();
 }
-async function generateTextWithPlaceholders(model, data, promptTemplate, options, debug = false) {
-  const { processedData, replacements } = createPlaceholders(data);
+async function generateTextWithPlaceholders(model, data, promptTemplate, options, debug = false, context) {
+  const { processedData, replacements } = context ? createPlaceholders(data, context) : createPlaceholders(data);
   if (debug && Object.keys(replacements).length > 0) {
     const savings = calculateTokenSavings(data, processedData);
     console.log(`[DEBUG] Placeholder optimization:`);
@@ -234765,7 +234784,34 @@ Generate ONLY the TypeScript code without any markdown or explanations.`;
   });
   writeFileSync3(outputPath, cleanGeneratedCode(text2));
 }
-async function generateAgentFile(agentData, agentId, outputPath, modelSettings, debug = false) {
+function generateImportMappings(toolFilenames, componentFilenames) {
+  let result = "";
+  if (toolFilenames && toolFilenames.size > 0) {
+    result += "TOOLS (use exact import paths):\n";
+    for (const [toolId, fileName] of toolFilenames.entries()) {
+      result += `  - Tool ID: "${toolId}" \u2192 Import: "../tools/${fileName.replace(".ts", "")}"
+`;
+    }
+    result += "\n";
+  }
+  if (componentFilenames && componentFilenames.size > 0) {
+    result += "COMPONENTS (use exact import paths):\n";
+    for (const [componentId, fileName] of componentFilenames.entries()) {
+      let directory = "components";
+      if (fileName.includes("data-") || componentId.includes("data-")) {
+        directory = "data-components";
+      } else if (fileName.includes("artifact-") || componentId.includes("artifact-")) {
+        directory = "artifact-components";
+      } else if (fileName.includes("status-") || componentId.includes("status-")) {
+        directory = "status-components";
+      }
+      result += `  - Component ID: "${componentId}" \u2192 Import: "../${directory}/${fileName.replace(".ts", "")}"
+`;
+    }
+  }
+  return result;
+}
+async function generateAgentFile(agentData, agentId, outputPath, modelSettings, toolFilenames, componentFilenames, debug = false) {
   const model = createModel(modelSettings);
   const promptTemplate = `Generate a TypeScript file for an Inkeep agent.
 
@@ -234774,11 +234820,22 @@ AGENT DATA:
 
 AGENT ID: ${agentId}
 
-${getTypeDefinitions()}
+${toolFilenames || componentFilenames ? `IMPORT PATH MAPPINGS (CRITICAL - USE EXACT PATHS):
+${generateImportMappings(toolFilenames, componentFilenames)}
+
+!!! WARNING: Entity IDs \u2260 File Paths !!!
+- Entity IDs may use underscores or different naming
+- File paths use kebab-case naming convention
+- ALWAYS use the exact import paths from the mappings above
+- NEVER use entity IDs directly as import paths
+
+` : ""}${getTypeDefinitions()}
 
 IMPORTANT CONTEXT:
 - Agents reference resources (tools, components) by their imported variable names
-- The 'tools' field in subAgents contains tool IDs that must match the imported variable names
+- Tools and components are referenced by variable names in code, but imports use FILE PATHS
+- CRITICAL: Import statements use file paths (../tools/tool-filename), NOT tool IDs
+- Variable names in canUse() arrays should match the imported variable names
 - If contextConfig is present, it must be imported from '@inkeep/agents-core' and used to create the context config
 
 ${NAMING_CONVENTION_RULES}
@@ -234786,7 +234843,10 @@ ${NAMING_CONVENTION_RULES}
 ${IMPORT_INSTRUCTIONS}
 
 REQUIREMENTS:
-1. IMPORTS (CRITICAL):
+1. IMPORTS (CRITICAL - USE FILE PATHS, NOT IDs):
+   - For tool/component imports: Use ONLY the exact file paths from IMPORT PATH MAPPINGS above
+   - Import paths are based on actual file names, not entity IDs
+   - Always use kebab-case file paths (../tools/tool-name, not ../tools/tool_name)
    - ALWAYS import { agent, subAgent } from '@inkeep/agents-sdk'
    - ALWAYS import { z } from 'zod' when using ANY Zod schemas (responseSchema, headersSchema, etc.)
    - ALWAYS import { contextConfig, fetchDefinition, headers } from '@inkeep/agents-core' when agent has contextConfig
@@ -235636,28 +235696,28 @@ var init_pull_llm_generate = __esm({
 `;
     NAMING_CONVENTION_RULES = `
 CRITICAL NAMING CONVENTION RULES (Apply to ALL imports/exports):
-- File names ALWAYS use the exact original ID. IDs are made of file safe characters (e.g., '../tools/inkeep_facts', '../data-components/user-profile')
-- Name of consts and variables, especially ones that are exported ones, MUST be camelCase versions of the ID, unless the ID is random/UUID then take it verbatim.
-- Conversion rules for import/export names:
+- File paths use kebab-case naming (e.g., '../tools/tool-name', '../data-components/component-name')
+- Variable names MUST be camelCase versions of the entity ID
+- Conversion rules for variable names:
   - IDs with underscores: 'inkeep_facts' \u2192 inkeepFacts
   - IDs with hyphens: 'weather-api' \u2192 weatherApi
   - IDs with both: 'my_weather-api' \u2192 myWeatherApi
   - Random/UUID IDs: Keep as-is (e.g., 'fUI2riwrBVJ6MepT8rjx0' \u2192 fUI2riwrBVJ6MepT8rjx0)
-  - IDs starting with uppercase: Make first letter lowercase unless it's an acronym or random or UUID
 - The ID field in the exported object keeps the original format
+- IMPORTANT: Import paths use kebab-case file names, NOT entity IDs
 - Examples:
-  - Tool: import { inkeepFacts } from '../tools/inkeep_facts'; export const inkeepFacts = mcpTool({ id: 'inkeep_facts', ... })
-  - Component: import { userProfile } from '../data-components/user-profile'; export const userProfile = dataComponent({ id: 'user-profile', ... })
-  - Agent: import { myAgent } from './agent/my-agent'; export const myAgent = agent({ id: 'my-agent', ... })
+  - Tool: import { toolName } from '../tools/tool-name'; export const toolName = mcpTool({ id: 'tool_id', ... })
+  - Component: import { componentName } from '../data-components/component-name'; export const componentName = dataComponent({ id: 'component-id', ... })
+  - Agent: import { agentName } from './agents/agent-name'; export const agentName = agent({ id: 'agent-id', ... })
 `;
     IMPORT_INSTRUCTIONS = `
 CRITICAL: All imports MUST be alphabetically sorted (both named imports and path names)
 
 CRITICAL IMPORT PATTERNS:
-- Tools: Import from '../tools/{toolId}' (individual files)
-- Data components: Import from '../data-components/{componentId}' (individual files)
-- Artifact components: Import from '../artifact-components/{componentId}' (individual files)
-- Agent: Import from './agent/{agentId}' (individual files)
+- Tools: Import from '../tools/{file-name}' (use kebab-case file names)
+- Data components: Import from '../data-components/{file-name}' (use kebab-case file names)
+- Artifact components: Import from '../artifact-components/{file-name}' (use kebab-case file names)
+- Agent: Import from './agents/{file-name}' (use kebab-case file names)
 
 NEVER use barrel imports from directories:
 \u274C WRONG: import { ordersList, refundApproval } from '../data-components';
@@ -235692,28 +235752,28 @@ function collectAllEntities(projectData) {
   const entities = [];
   if (projectData.agents) {
     for (const [agentId, agentData] of Object.entries(projectData.agents)) {
-      entities.push({ id: agentId, type: "agent" });
+      entities.push({ id: agentId, type: "agent", data: agentData });
       const agentObj = agentData;
       if (agentObj.subAgents) {
-        for (const subAgentId of Object.keys(agentObj.subAgents)) {
-          entities.push({ id: subAgentId, type: "subAgent" });
+        for (const [subAgentId, subAgentData] of Object.entries(agentObj.subAgents)) {
+          entities.push({ id: subAgentId, type: "subAgent", data: subAgentData });
         }
       }
     }
   }
   if (projectData.tools) {
-    for (const toolId of Object.keys(projectData.tools)) {
-      entities.push({ id: toolId, type: "tool" });
+    for (const [toolId, toolData] of Object.entries(projectData.tools)) {
+      entities.push({ id: toolId, type: "tool", data: toolData });
     }
   }
   if (projectData.dataComponents) {
-    for (const compId of Object.keys(projectData.dataComponents)) {
-      entities.push({ id: compId, type: "dataComponent" });
+    for (const [compId, compData] of Object.entries(projectData.dataComponents)) {
+      entities.push({ id: compId, type: "dataComponent", data: compData });
     }
   }
   if (projectData.artifactComponents) {
-    for (const compId of Object.keys(projectData.artifactComponents)) {
-      entities.push({ id: compId, type: "artifactComponent" });
+    for (const [compId, compData] of Object.entries(projectData.artifactComponents)) {
+      entities.push({ id: compId, type: "artifactComponent", data: compData });
     }
   }
   if (projectData.agents) {
@@ -235728,9 +235788,58 @@ function collectAllEntities(projectData) {
       }
     }
   }
+  const credentialReferences2 = /* @__PURE__ */ new Set();
   if (projectData.credentialReferences) {
     for (const credId of Object.keys(projectData.credentialReferences)) {
-      entities.push({ id: credId, type: "credential" });
+      credentialReferences2.add(credId);
+    }
+  }
+  if (projectData.tools) {
+    for (const [_toolId, toolData] of Object.entries(projectData.tools)) {
+      const tool2 = toolData;
+      if (tool2.credentialReferenceId) {
+        credentialReferences2.add(tool2.credentialReferenceId);
+      }
+    }
+  }
+  if (projectData.externalAgents) {
+    for (const [_agentId, agentData] of Object.entries(projectData.externalAgents)) {
+      const agent = agentData;
+      if (agent.credentialReferenceId) {
+        credentialReferences2.add(agent.credentialReferenceId);
+      }
+    }
+  }
+  if (projectData.agents) {
+    for (const [_agentId, agentData] of Object.entries(projectData.agents)) {
+      const agent = agentData;
+      if (agent.contextConfig?.headers?.credentialReferenceId) {
+        credentialReferences2.add(agent.contextConfig.headers.credentialReferenceId);
+      }
+      if (agent.contextConfig?.contextVariables) {
+        for (const [_varId, varData] of Object.entries(agent.contextConfig.contextVariables)) {
+          const contextVar = varData;
+          if (contextVar.credentialReferenceId) {
+            credentialReferences2.add(contextVar.credentialReferenceId);
+          }
+        }
+      }
+      if (agent.subAgents) {
+        for (const [_subAgentId, subAgentData] of Object.entries(agent.subAgents)) {
+          const subAgent = subAgentData;
+          if (subAgent.contextConfig?.headers?.credentialReferenceId) {
+            credentialReferences2.add(subAgent.contextConfig.headers.credentialReferenceId);
+          }
+          if (subAgent.contextConfig?.contextVariables) {
+            for (const [_varId, varData] of Object.entries(subAgent.contextConfig.contextVariables)) {
+              const contextVar = varData;
+              if (contextVar.credentialReferenceId) {
+                credentialReferences2.add(contextVar.credentialReferenceId);
+              }
+            }
+          }
+        }
+      }
     }
   }
   return entities;
@@ -235748,7 +235857,9 @@ var init_variable_name_registry = __esm({
       dataComponentSuffix: null,
       artifactComponentSuffix: null,
       statusComponentSuffix: null,
-      credentialSuffix: null
+      credentialSuffix: null,
+      environmentSuffix: null
+      // No suffix needed for environments
     };
     VariableNameGenerator = class {
       registry;
@@ -235763,6 +235874,7 @@ var init_variable_name_registry = __esm({
           artifactComponents: /* @__PURE__ */ new Map(),
           statusComponents: /* @__PURE__ */ new Map(),
           credentials: /* @__PURE__ */ new Map(),
+          environments: /* @__PURE__ */ new Map(),
           usedNames: /* @__PURE__ */ new Map()
         };
         this.conventions = conventions;
@@ -235772,13 +235884,18 @@ var init_variable_name_registry = __esm({
        * Generate unique variable name for an entity
        * Ensures no conflicts across all entity types
        */
-      generateVariableName(id, entityType) {
+      generateVariableName(id, entityType, entityData) {
         const registryMap = this.getRegistryMap(entityType);
         const existing = registryMap.get(id);
         if (existing) {
           return existing;
         }
-        const baseName = this.idToVariableName(id);
+        let baseName;
+        if (entityType === "tool" && entityData?.name && this.isRandomId(id)) {
+          baseName = this.idToVariableName(entityData.name);
+        } else {
+          baseName = this.idToVariableName(id);
+        }
         if (!this.registry.usedNames.has(baseName)) {
           this.register(id, baseName, entityType);
           return baseName;
@@ -235858,6 +235975,30 @@ var init_variable_name_registry = __esm({
         }
         return false;
       }
+      /**
+       * Generate filename from entity data (for file naming)
+       */
+      generateFileName(id, entityType, entityData) {
+        let baseName;
+        if (entityType === "tool" && entityData?.name && this.isRandomId(id)) {
+          baseName = this.nameToFileName(entityData.name);
+        } else {
+          baseName = this.idToFileName(id);
+        }
+        return baseName;
+      }
+      /**
+       * Convert name to kebab-case filename
+       */
+      nameToFileName(name) {
+        return name.replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+      }
+      /**
+       * Convert ID to kebab-case filename
+       */
+      idToFileName(id) {
+        return id.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+      }
       /**
        * Get appropriate suffix for entity type
        */
@@ -235877,6 +236018,8 @@ var init_variable_name_registry = __esm({
             return this.conventions.statusComponentSuffix || "";
           case "credential":
             return this.conventions.credentialSuffix || "";
+          case "environment":
+            return this.conventions.environmentSuffix || "";
           default:
             return "";
         }
@@ -235900,6 +236043,8 @@ var init_variable_name_registry = __esm({
             return this.registry.statusComponents;
           case "credential":
             return this.registry.credentials;
+          case "environment":
+            return this.registry.environments;
           default:
             throw new Error(`Unknown entity type: ${entityType}`);
         }
@@ -235929,10 +236074,12 @@ async function analyzeExistingPatterns(projectDir) {
     namingConventions,
     codeStyle,
     examples: {
-      sampleAgentFile: codeExamples.agentFiles[0]?.content,
-      sampleToolFile: codeExamples.toolFiles[0]?.content,
-      sampleImports: codeExamples.imports,
-      mappings: codeExamples.mappings
+      // Sample files removed to prevent misleading examples
+      // sampleAgentFile: codeExamples.agentFiles[0]?.content,
+      // sampleToolFile: codeExamples.toolFiles[0]?.content,
+      // sampleImports: codeExamples.imports,  // Disabled - imports cause confusion with kebab-case vs underscore paths
+      mappings: []
+      // Disabled sample mappings to prevent bad examples from contaminating generation
     }
   };
 }
@@ -236389,7 +236536,7 @@ var plan_builder_exports = {};
 __export(plan_builder_exports, {
   generatePlan: () => generatePlan
 });
-async function generatePlan(projectData, patterns, modelSettings, createModel2) {
+async function generatePlan(projectData, patterns, modelSettings, createModel2, targetEnvironment = "development") {
   const nameGenerator = new VariableNameGenerator(patterns.namingConventions);
   if (patterns.examples.mappings) {
     for (const mapping of patterns.examples.mappings) {
@@ -236401,10 +236548,15 @@ async function generatePlan(projectData, patterns, modelSettings, createModel2)
   }
   const allEntities = collectAllEntities(projectData);
   for (const entity of allEntities) {
-    nameGenerator.generateVariableName(entity.id, entity.type);
+    nameGenerator.generateVariableName(entity.id, entity.type, entity.data);
+  }
+  const fileNameMappings = /* @__PURE__ */ new Map();
+  for (const entity of allEntities) {
+    const fileName = nameGenerator.generateFileName(entity.id, entity.type, entity.data);
+    fileNameMappings.set(entity.id, fileName);
   }
   const model = createModel2(modelSettings);
-  const promptTemplate = createPlanningPromptTemplate(nameGenerator.getRegistry(), allEntities);
+  const promptTemplate = createPlanningPromptTemplate(nameGenerator.getRegistry(), allEntities, fileNameMappings, targetEnvironment);
   const promptData = {
     projectData,
     patterns
@@ -236435,8 +236587,9 @@ async function generatePlan(projectData, patterns, modelSettings, createModel2)
   };
   return plan;
 }
-function createPlanningPromptTemplate(registry2, allEntities) {
+function createPlanningPromptTemplate(registry2, allEntities, fileNameMappings, targetEnvironment = "development") {
   const mappings = formatVariableMappings(registry2, allEntities);
+  const fileNames = formatFileNameMappings(fileNameMappings, allEntities);
   return `You are a code generation planner. Generate a file structure plan for an Inkeep TypeScript project.
 
 DATA (PROJECT AND PATTERNS):
@@ -236449,6 +236602,9 @@ The DATA above contains:
 VARIABLE NAME MAPPINGS (MUST USE THESE EXACT NAMES):
 ${mappings}
 
+FILENAME MAPPINGS (MUST USE THESE EXACT FILENAMES):
+${fileNames}
+
 CRITICAL RULES:
 
 1. TOOL TYPES - VERY IMPORTANT:
@@ -236464,7 +236620,14 @@ CRITICAL RULES:
    - Agents must import status components from status-components/ directory
    - Status components are NEVER inlined in agent files
 
-3. File Structure:
+3. ENVIRONMENT FILES - VERY IMPORTANT:
+   - **When credential references exist**: Create environment files in environments/ directory
+   - **Environment Structure**: Create ONLY "${targetEnvironment}.env.ts" file for target environment (credentials are embedded in this file)
+   - **Environment Index**: Create "environments/index.ts" that imports environment files and exports envSettings using createEnvironmentSettings
+   - **NO separate credential files**: Credentials are defined INSIDE the environment files, not as separate files
+   - **Environment entities**: Use type "environment" for both environment files and index file
+
+4. File Structure:
    - If patterns show "toolsLocation": "inline", ALL tools should be in "inlineContent" of agent files
    - If patterns show "toolsLocation": "separate", MCP tools get separate files, function tools still inline
    - Follow the detected file naming convention (kebab-case, camelCase, or snake_case)
@@ -236558,6 +236721,40 @@ OUTPUT FORMAT (JSON):
       "dependencies": [],
       "inlineContent": null
     },
+    {
+      "path": "environments/${targetEnvironment}.env.ts",
+      "type": "environment",
+      "entities": [
+        {
+          "id": "${targetEnvironment}",
+          "variableName": "${targetEnvironment}",
+          "entityType": "environment",
+          "exportName": "${targetEnvironment}"
+        }
+      ],
+      "dependencies": [],
+      "inlineContent": null
+    },
+    {
+      "path": "environments/index.ts", 
+      "type": "environment",
+      "entities": [
+        {
+          "id": "envSettings",
+          "variableName": "envSettings",
+          "entityType": "environment",
+          "exportName": "envSettings"
+        }
+      ],
+      "dependencies": [
+        {
+          "variableName": "${targetEnvironment}",
+          "fromPath": "./${targetEnvironment}.env",
+          "entityType": "environment"
+        }
+      ],
+      "inlineContent": null
+    },
     {
       "path": "index.ts",
       "type": "index",
@@ -236596,7 +236793,8 @@ function formatVariableMappings(registry2, allEntities) {
     dataComponent: [],
     artifactComponent: [],
     statusComponent: [],
-    credential: []
+    credential: [],
+    environment: []
   };
   for (const entity of allEntities) {
     const registryMap = getRegistryMap(registry2, entity.type);
@@ -236618,6 +236816,45 @@ ${type.toUpperCase()}S:
   }
   return result;
 }
+function formatFileNameMappings(fileNameMappings, allEntities) {
+  let result = "";
+  const byType = {
+    agent: [],
+    tool: [],
+    dataComponent: [],
+    artifactComponent: [],
+    statusComponent: [],
+    credential: []
+  };
+  for (const entity of allEntities) {
+    const fileName = fileNameMappings.get(entity.id);
+    if (fileName && byType[entity.type]) {
+      byType[entity.type].push({
+        id: entity.id,
+        fileName,
+        name: entity.data?.name
+        // Include human-readable name for context
+      });
+    }
+  }
+  for (const [type, entities] of Object.entries(byType)) {
+    if (entities.length > 0) {
+      result += `
+${type.toUpperCase()}S:
+`;
+      for (const entity of entities) {
+        if (entity.name && entity.name !== entity.id) {
+          result += `  - id: "${entity.id}" (${entity.name}) \u2192 filename: "${entity.fileName}.ts"
+`;
+        } else {
+          result += `  - id: "${entity.id}" \u2192 filename: "${entity.fileName}.ts"
+`;
+        }
+      }
+    }
+  }
+  return result;
+}
 function getRegistryMap(registry2, entityType) {
   switch (entityType) {
     case "agent":
@@ -236806,7 +237043,8 @@ async function generateFile(fileInfo, projectData, plan, dirs, modelSettings, de
         maxOutputTokens: fileInfo.type === "agent" ? 16e3 : 4e3,
         abortSignal: AbortSignal.timeout(fileInfo.type === "agent" ? 24e4 : 6e4)
       },
-      debug
+      debug,
+      { fileType: fileInfo.type }
     );
     const llmDuration = ((Date.now() - llmStartTime) / 1e3).toFixed(1);
     const cleanedCode = cleanGeneratedCode(text2);
@@ -236869,21 +237107,154 @@ function extractDataForFile(fileInfo, projectData) {
       }
       return {};
     }
-    case "environment":
-      return projectData.credentialReferences || {};
+    case "environment": {
+      const credentialData = {};
+      const sources = [];
+      if (projectData.credentialReferences) {
+        Object.assign(credentialData, projectData.credentialReferences);
+        sources.push("direct credentialReferences");
+      }
+      if (projectData.tools) {
+        for (const [toolId, toolData] of Object.entries(projectData.tools)) {
+          const tool2 = toolData;
+          if (tool2.credentialReferenceId && !credentialData[tool2.credentialReferenceId]) {
+            credentialData[tool2.credentialReferenceId] = {
+              id: tool2.credentialReferenceId,
+              type: "api_key",
+              description: `Credential for tool ${tool2.name || toolId}`,
+              _context: {
+                source: "tool",
+                toolId,
+                toolName: tool2.name,
+                serverUrl: tool2.serverUrl
+              }
+            };
+            sources.push(`tool:${toolId}`);
+          }
+        }
+      }
+      if (projectData.externalAgents) {
+        for (const [agentId, agentData] of Object.entries(projectData.externalAgents)) {
+          const agent = agentData;
+          if (agent.credentialReferenceId && !credentialData[agent.credentialReferenceId]) {
+            credentialData[agent.credentialReferenceId] = {
+              id: agent.credentialReferenceId,
+              type: "api_key",
+              description: `Credential for external agent ${agent.name || agentId}`,
+              _context: {
+                source: "externalAgent",
+                agentId,
+                agentName: agent.name,
+                baseUrl: agent.baseUrl
+              }
+            };
+            sources.push(`externalAgent:${agentId}`);
+          }
+        }
+      }
+      if (projectData.agents) {
+        for (const [agentId, agentData] of Object.entries(projectData.agents)) {
+          const agent = agentData;
+          if (agent.contextConfig?.headers?.credentialReferenceId) {
+            const credId = agent.contextConfig.headers.credentialReferenceId;
+            if (!credentialData[credId]) {
+              credentialData[credId] = {
+                id: credId,
+                type: "api_key",
+                description: `Credential for agent ${agent.name || agentId} headers`,
+                _context: {
+                  source: "agent.contextConfig.headers",
+                  agentId,
+                  agentName: agent.name
+                }
+              };
+              sources.push(`agent:${agentId}:headers`);
+            }
+          }
+          if (agent.contextConfig?.contextVariables) {
+            for (const [varId, varData] of Object.entries(agent.contextConfig.contextVariables)) {
+              const contextVar = varData;
+              if (contextVar.credentialReferenceId) {
+                const credId = contextVar.credentialReferenceId;
+                if (!credentialData[credId]) {
+                  credentialData[credId] = {
+                    id: credId,
+                    type: "api_key",
+                    description: `Credential for agent ${agent.name || agentId} context variable ${varId}`,
+                    _context: {
+                      source: "agent.contextConfig.contextVariables",
+                      agentId,
+                      agentName: agent.name,
+                      variableId: varId
+                    }
+                  };
+                  sources.push(`agent:${agentId}:contextVar:${varId}`);
+                }
+              }
+            }
+          }
+          if (agent.subAgents) {
+            for (const [subAgentId, subAgentData] of Object.entries(agent.subAgents)) {
+              const subAgent = subAgentData;
+              if (subAgent.contextConfig?.headers?.credentialReferenceId) {
+                const credId = subAgent.contextConfig.headers.credentialReferenceId;
+                if (!credentialData[credId]) {
+                  credentialData[credId] = {
+                    id: credId,
+                    type: "api_key",
+                    description: `Credential for subAgent ${subAgent.name || subAgentId} headers`,
+                    _context: {
+                      source: "subAgent.contextConfig.headers",
+                      agentId,
+                      subAgentId,
+                      subAgentName: subAgent.name
+                    }
+                  };
+                  sources.push(`subAgent:${subAgentId}:headers`);
+                }
+              }
+              if (subAgent.contextConfig?.contextVariables) {
+                for (const [varId, varData] of Object.entries(subAgent.contextConfig.contextVariables)) {
+                  const contextVar = varData;
+                  if (contextVar.credentialReferenceId) {
+                    const credId = contextVar.credentialReferenceId;
+                    if (!credentialData[credId]) {
+                      credentialData[credId] = {
+                        id: credId,
+                        type: "api_key",
+                        description: `Credential for subAgent ${subAgent.name || subAgentId} context variable ${varId}`,
+                        _context: {
+                          source: "subAgent.contextConfig.contextVariables",
+                          agentId,
+                          subAgentId,
+                          subAgentName: subAgent.name,
+                          variableId: varId
+                        }
+                      };
+                      sources.push(`subAgent:${subAgentId}:contextVar:${varId}`);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (Object.keys(credentialData).length > 0) {
+        credentialData._meta = {
+          foundCredentials: Object.keys(credentialData).filter((k2) => k2 !== "_meta"),
+          sources,
+          extractedFrom: "comprehensive scan of project data"
+        };
+      }
+      return credentialData;
+    }
     default:
       return {};
   }
 }
 function findExampleCode(fileInfo, patterns) {
-  switch (fileInfo.type) {
-    case "agent":
-      return patterns.examples.sampleAgentFile;
-    case "tool":
-      return patterns.examples.sampleToolFile;
-    default:
-      return void 0;
-  }
+  return void 0;
 }
 function createPromptForFile(fileInfo, fileData, context, registryInfo) {
   const commonInstructions = `
@@ -236907,11 +237278,13 @@ ${NAMING_CONVENTION_RULES}
 ${IMPORT_INSTRUCTIONS}
 
 CRITICAL RULES:
-1. Use EXACT variable names from the registry above
-2. The 'id' field in objects keeps the original value
-3. Variable names must be unique (no conflicts across types)
-4. Follow detected patterns for code style
-5. Match existing formatting and conventions
+1. Use EXACT variable names from the registry above - DO NOT modify or "improve" them
+2. Copy the exact import statements provided in the registry
+3. The 'id' field in objects keeps the original value
+4. Variable names must be unique (no conflicts across types)
+5. Follow detected patterns for code style
+6. Match existing formatting and conventions
+7. NEVER generate your own variable names - only use what's provided
 `;
   switch (fileInfo.type) {
     case "index":
@@ -236926,12 +237299,14 @@ CRITICAL RULES:
       return createArtifactComponentPrompt(fileData, context, registryInfo, commonInstructions);
     case "statusComponent":
       return createStatusComponentPrompt(fileData, context, registryInfo, commonInstructions);
+    case "environment":
+      return createEnvironmentPrompt(fileData, context, registryInfo, commonInstructions);
     default:
       throw new Error(`Unknown file type: ${fileInfo.type}`);
   }
 }
 function createIndexPrompt(_projectData, context, _registryInfo, commonInstructions) {
-  const importMappings = generateImportMappings(context.plan);
+  const importMappings = generateImportMappings2(context.plan);
   return `Generate index.ts for Inkeep project.
 
 PROJECT DATA:
@@ -237035,6 +237410,34 @@ CONTEXT CONFIG (CRITICAL - NO PLAIN OBJECTS):
 - Use myHeaders.toTemplate('key_name') for header values in fetchConfig
 - Use myContext.toTemplate('variable.field') for prompt interpolation
 
+FETCHDEFINITION STRUCTURE (CRITICAL - COPY EXACT FORMAT):
+- ALWAYS wrap HTTP config in 'fetchConfig' object
+- COPY the exact authorization format from source data (don't modify headers)
+- Use .nullable() instead of z.union([type, z.null()]) for schemas
+- responseSchema is raw Zod code (NO backticks around it)
+- String values use template literals (backticks for strings)
+
+CORRECT fetchDefinition structure:
+fetchDefinition({
+  id: 'fetch-id',
+  name: 'Fetch Name',
+  trigger: 'initialization',
+  fetchConfig: {
+    url: 'api-endpoint-url',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: headersVar.toTemplate('key') // COPY EXACT format from source
+    },
+    body: { query: 'request-body' }
+  },
+  responseSchema: z.object({
+    field: z.string().nullable()
+  }),
+  transform: 'data.path',
+  defaultValue: 'fallback'
+})
+
 STRING LITERALS (CRITICAL - MUST FOLLOW):
 - For STRING VALUES: ALWAYS use template literals (backticks \`)
 - This includes: prompt, description, query, url, method, body, defaultValue, etc.
@@ -237113,7 +237516,28 @@ REQUIREMENTS:
 1. Import mcpTool or functionTool from '@inkeep/agents-sdk'
 2. Use exact variable name from registry
 3. Include serverUrl property if MCP tool
-4. Handle credentials using envSettings if needed
+4. For tools with credentials, import envSettings and use envSettings.getEnvironmentSetting('credential_key')
+5. CRITICAL: Transport must be an OBJECT format: transport: { type: 'streamable_http' } NOT a string
+
+CREDENTIAL HANDLING (CRITICAL):
+If the tool data includes credential information, you MUST:
+1. Import { envSettings } from '../environments'
+2. Use credential: envSettings.getEnvironmentSetting('credential_key') in the tool definition
+3. Convert credential IDs to underscore format (e.g., 'linear-api' -> 'linear_api')
+
+Example for tool with credential:
+\`\`\`typescript
+import { mcpTool } from '@inkeep/agents-sdk';
+import { envSettings } from '../environments';
+
+export const toolName = mcpTool({
+  id: 'tool-id',
+  name: 'Tool Name',
+  serverUrl: 'https://example.com/mcp',
+  credential: envSettings.getEnvironmentSetting('linear_api'), // underscore format
+  transport: { type: 'streamable_http' }
+});
+\`\`\`
 
 Generate ONLY the TypeScript code without markdown.`;
 }
@@ -237130,46 +237554,58 @@ dataComponent({
   id: 'component-id',
   name: 'ComponentName',
   description: 'Component description',
-  props: {  // Use 'props' NOT 'propsSchema'
-    $schema: 'https://json-schema.org/draft/2020-12/schema',
-    type: 'object',
-    properties: { ... },
-    required: [...],
-    additionalProperties: false
-  }
+  props: z.object({
+    fieldName: z.string().describe('Field description'),
+    optionalField: z.number().optional().describe('Optional field description'),
+  })
 })
 
+REQUIREMENTS:
+1. Import dataComponent from '@inkeep/agents-sdk'
+2. Import z from 'zod' for schema definitions
+3. Use exact variable name from registry
+4. Use 'props' property with Zod schema (NOT JSON Schema)
+5. Include 'id', 'name', and 'description' properties
+6. Use .describe() for field descriptions
+7. Use .optional() for optional fields
+8. Use .nullable() for nullable fields (not z.union([z.string(), z.null()]))
+9. CRITICAL: All imports must be alphabetically sorted to comply with Biome linting
+
 EXAMPLE:
+import { dataComponent } from '@inkeep/agents-sdk';
+import { z } from 'zod';
+
 export const weatherForecast = dataComponent({
   id: 'weather-forecast',
   name: 'WeatherForecast',
   description: 'Hourly weather forecast',
-  props: {
-    $schema: 'https://json-schema.org/draft/2020-12/schema',
-    type: 'object',
-    properties: {
-      forecast: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            time: { type: 'string' },
-            temperature: { type: 'number' }
-          },
-          required: ['time', 'temperature']
-        }
-      }
-    },
-    required: ['forecast'],
-    additionalProperties: false
-  }
+  props: z.object({
+    forecast: z.array(z.object({
+      time: z.string().describe('The time of current item E.g. 12PM, 1PM'),
+      temperature: z.number().describe('Temperature at given time in Fahrenheit'),
+      code: z.number().describe('Weather code at given time'),
+    })).describe('The hourly forecast for the weather at a given location'),
+  }),
 });
 
-REQUIREMENTS:
-1. Import dataComponent from '@inkeep/agents-sdk'
-2. Use exact variable name from registry
-3. Use 'props' property with JSON Schema format
-4. Include 'id', 'name', and 'description' properties
+EXAMPLE WITH OPTIONAL FIELDS:
+import { dataComponent } from '@inkeep/agents-sdk';
+import { z } from 'zod';
+
+export const userProfile = dataComponent({
+  id: 'user-profile',
+  name: 'User Profile',
+  description: 'User profile information',
+  props: z.object({
+    userId: z.string().describe('Unique user identifier'),
+    name: z.string().describe('User full name'),
+    email: z.string().email().describe('User email address'),
+    preferences: z.object({
+      theme: z.enum(['light', 'dark']),
+      notifications: z.boolean(),
+    }).optional().describe('User preferences'),
+  }),
+});
 
 Generate ONLY the TypeScript code without markdown.`;
 }
@@ -237222,28 +237658,44 @@ export const toolSummary = statusComponent({
 Generate ONLY the TypeScript code without markdown.`;
 }
 function formatRegistryForFile(fileInfo, _registry) {
-  let result = "Entities in this file:\n";
-  for (const entity of fileInfo.entities) {
-    result += `  - ${entity.entityType} "${entity.id}" \u2192 variable: ${entity.variableName}
+  let result = "REQUIRED VARIABLE NAMES (YOU MUST USE ONLY THESE EXACT NAMES):\n\n";
+  if (fileInfo.entities.length > 0) {
+    result += "Variables to define in this file:\n";
+    for (const entity of fileInfo.entities) {
+      result += `  - ID "${entity.id}" \u2192 MUST use variable name: ${entity.variableName}
 `;
+    }
+    result += "\n";
   }
   if (fileInfo.inlineContent && fileInfo.inlineContent.length > 0) {
-    result += "\nInline content (defined in this file):\n";
+    result += "Inline variables to define in this file:\n";
     for (const entity of fileInfo.inlineContent) {
-      result += `  - ${entity.entityType} "${entity.id}" \u2192 variable: ${entity.variableName}
+      result += `  - ID "${entity.id}" \u2192 MUST use variable name: ${entity.variableName}
 `;
     }
+    result += "\n";
   }
   if (fileInfo.dependencies.length > 0) {
-    result += "\nDependencies to import:\n";
+    result += "!!! EXACT IMPORT STATEMENTS - COPY PRECISELY !!!\n";
     for (const dep of fileInfo.dependencies) {
-      result += `  - import { ${dep.variableName} } from '${dep.fromPath}';
+      result += `import { ${dep.variableName} } from '${dep.fromPath}';
 `;
     }
+    result += "\n";
+    result += "!!! WARNING: IDs \u2260 FILE PATHS !!!\n";
+    result += "Entity IDs (with underscores) are NOT the same as file paths (with kebab-case):\n";
+    for (const dep of fileInfo.dependencies) {
+      const entity = fileInfo.entities.find((e2) => e2.variableName === dep.variableName) || fileInfo.inlineContent?.find((e2) => e2.variableName === dep.variableName);
+      if (entity && entity.id !== dep.fromPath.split("/").pop()?.replace(".ts", "")) {
+        result += `- Entity ID: "${entity.id}" \u2192 File path: "${dep.fromPath}"
+`;
+      }
+    }
+    result += "\nCRITICAL: Use the FILE PATHS above, NOT the entity IDs!\n\n";
   }
   return result;
 }
-function generateImportMappings(plan) {
+function generateImportMappings2(plan) {
   let result = "";
   for (const file of plan.files) {
     if (file.type !== "index" && file.type !== "environment") {
@@ -237256,6 +237708,97 @@ function generateImportMappings(plan) {
   }
   return result;
 }
+function createEnvironmentPrompt(credentialData, context, _registryInfo, commonInstructions) {
+  const filePath = context.fileInfo.path || "";
+  const fileName = filePath.split("/").pop() || "";
+  if (fileName === "index.ts") {
+    const environmentFiles = context.plan.files.filter(
+      (f) => f.type === "environment" && f.path !== "environments/index.ts"
+    );
+    const imports = environmentFiles.map((envFile) => {
+      const envEntity = envFile.entities[0];
+      if (envEntity) {
+        return `import { ${envEntity.variableName} } from './${envFile.path.replace("environments/", "").replace(".ts", "")}';`;
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+    const envSettings = environmentFiles.map((envFile) => {
+      const envEntity = envFile.entities[0];
+      return envEntity ? `  ${envEntity.variableName},` : "";
+    }).filter(Boolean).join("\n");
+    return `${commonInstructions}
+
+ENVIRONMENTS INDEX FILE (CRITICAL):
+
+Create an environments/index.ts file that exports environment settings using createEnvironmentSettings.
+
+CREDENTIAL DATA (from project):
+${JSON.stringify(credentialData, null, 2)}
+
+EXACT IMPORT STATEMENTS (MUST USE THESE):
+${imports}
+
+ENVIRONMENTS INDEX STRUCTURE (MUST FOLLOW EXACTLY):
+
+import { createEnvironmentSettings } from '@inkeep/agents-sdk';
+${imports}
+
+export const envSettings = createEnvironmentSettings({
+${envSettings}
+});
+
+CRITICAL RULES:
+1. Import createEnvironmentSettings from '@inkeep/agents-sdk'
+2. Use the EXACT import statements provided above - DO NOT modify them
+3. Use the EXACT variable names in the createEnvironmentSettings object
+4. Export envSettings using createEnvironmentSettings()
+5. Include all environments that have credential files
+
+Generate ONLY the TypeScript code without markdown.`;
+  }
+  const envName = fileName.replace(".env.ts", "") || "development";
+  return `${commonInstructions}
+
+ENVIRONMENT FILE (CRITICAL):
+
+Create an environment file that registers credential settings for the "${envName}" environment.
+
+CREDENTIAL DATA (from project):
+${JSON.stringify(credentialData, null, 2)}
+
+ENVIRONMENT FILE STRUCTURE (MUST FOLLOW EXACTLY):
+
+import { credential, registerEnvironmentSettings } from '@inkeep/agents-sdk';
+
+export const ${envName} = registerEnvironmentSettings({
+  credentials: {
+    CREDENTIAL_KEY: credential({
+      id: 'CREDENTIAL_ID',
+      type: 'CREDENTIAL_TYPE', 
+      credentialStoreId: 'CREDENTIAL_STORE_ID',
+      retrievalParams: {
+        key: 'ENV_VARIABLE_NAME'
+      }
+    })
+  }
+});
+
+CRITICAL RULES:
+1. Import { credential, registerEnvironmentSettings } from '@inkeep/agents-sdk'
+2. Export a const named "${envName}" (matching the environment)
+3. Use registerEnvironmentSettings() wrapper
+4. Create credential() objects for each credential in the data
+5. Convert credential IDs to environment variable keys (e.g., 'linear-api' -> 'LINEAR_API_KEY')
+6. Use exact credential IDs, types, and credentialStoreId from the data provided
+7. Set retrievalParams.key to the environment variable name (uppercase with underscores)
+
+Example for credential with id 'linear-api':
+- Export const: ${envName}
+- Credential key: linear_api (underscore format for object key)
+- retrievalParams.key: 'LINEAR_API_KEY' (uppercase for environment variable)
+
+Generate ONLY the TypeScript code without markdown.`;
+}
 var init_unified_generator = __esm({
   "src/codegen/unified-generator.ts"() {
     "use strict";
@@ -238788,6 +239331,7 @@ function performBackgroundVersionCheck() {
 
 // src/commands/pull.ts
 init_pull_llm_generate();
+init_variable_name_registry();
 async function detectCurrentProject(debug = false) {
   const indexPath = join10(process.cwd(), "index.ts");
   if (debug) {
@@ -238897,14 +239441,15 @@ async function verifyGeneratedFiles(projectDir, originalProjectData, debug = fal
       }
     }
     const toolsDir = join10(projectDir, "tools");
-    const expectedTools = Object.keys(originalProjectData.tools || {});
-    for (const toolId of expectedTools) {
-      const kebabCaseId = toolId.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-      const toolPath = join10(toolsDir, `${kebabCaseId}.ts`);
+    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)) {
-        errors.push(`Tool file not found: tools/${kebabCaseId}.ts`);
+        errors.push(`Tool file not found: tools/${fileName}.ts`);
       } else if (debug) {
-        console.log(chalk9.gray(`  \u2713 Tool file exists: tools/${kebabCaseId}.ts`));
+        console.log(chalk9.gray(`  \u2713 Tool file exists: tools/${fileName}.ts`));
       }
     }
     const dataComponentsDir = join10(projectDir, "data-components");
@@ -239307,7 +239852,8 @@ async function pullProjectCommand(options) {
     const modelSettings = {
       model: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5
     };
-    const plan = await generatePlan2(projectData, patterns, modelSettings, createModel2);
+    const targetEnvironment = options.env || "development";
+    const plan = await generatePlan2(projectData, patterns, modelSettings, createModel2, targetEnvironment);
     spinner.succeed("Generation plan created");
     const { displayPlanSummary: displayPlanSummary2, displayConflictWarning: displayConflictWarning2 } = await Promise.resolve().then(() => (init_display_utils(), display_utils_exports));
     displayPlanSummary2(plan);

package/package.json

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