@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.e38f7bd

package/analyzer-template/packages/ai/src/lib/generateEntityKeyAttributes.ts

@@ -1,6 +1,6 @@
 import completionCall from './completionCall';
 import { saveLlmCall } from '~codeyam/aws/dynamodb';
-import { Entity } from '~codeyam/types';
+import { DataStructure, Entity } from '~codeyam/types';
 import generateEntityKeyAttributesGenerator from './promptGenerators/generateEntityKeyAttributesGenerator';
 import { awsLog } from '~codeyam/utils';
 import { DEFAULT_LARGER_MODEL } from './aiConfig';
@@ -13,11 +13,13 @@ import type { ConditionalUsage } from '~codeyam/types';
 
 interface GenerateEntityKeyAttributesArgs {
   entity: Pick<Entity, 'sha' | 'name' | 'filePath' | 'code' | 'metadata'>;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
   model?: AI.Model;
 }
 
 export default async function generateEntityKeyAttributes({
   entity,
+  mergedDataStructure,
   model,
 }: GenerateEntityKeyAttributesArgs) {
   awsLog(`CodeYam: Generating entity key attributes`, {
@@ -25,8 +27,16 @@ export default async function generateEntityKeyAttributes({
     entityName: entity.name,
   });
 
+  const isolatedDataStructure = entity.metadata?.isolatedDataStructure;
+  const equivalentSignatureVariables =
+    isolatedDataStructure?.equivalentSignatureVariables ?? {};
   const { attributesMap, associationMap, dataStructurePathMap } =
-    gatherAttributesMap(entity, true);
+    gatherAttributesMap(
+      isolatedDataStructure ?? mergedDataStructure,
+      mergedDataStructure,
+      equivalentSignatureVariables,
+      true,
+    );
 
   if (Object.keys(attributesMap).length === 0) {
     console.log(
@@ -142,6 +152,9 @@ export default async function generateEntityKeyAttributes({
         description: keyAttribute.description,
         validValueOptions: keyAttribute.validValueOptions,
         errorValueOptions: keyAttribute.errorValueOptions,
+        // Preserve new fields from LLM response
+        valueType: keyAttribute.valueType,
+        dependencies: keyAttribute.dependencies,
       };
     });
 
@@ -177,9 +190,20 @@ Each conditional lists it's source and how it is used. This should help you iden
 
 Only return attributes from the "Attributes and Value Types" list — these are the only values we can control. Use the exact \`fullPath\` provided. Use \`functionCallReturnValue\` for function return values. Use \`[]\` for array items (e.g., \`items[]\`).
 
+## Dependencies
+
+If this key attribute is only used if one or more other attributes have specific values, include those dependencies in a \`dependencies\` array.
+
+## Value Type
+
+Should reiterate the type of the attribute (e.g., "string", "object", "array", "boolean", etc.) based on the "Attributes and Value Types" list.
+
+All validValueOptions must be of this type.
+
 ## Valid Value Options
 
-- For \`validValueOptions\`, include boundary/extreme values that trigger different behavior 
+- For \`validValueOptions\`, include boundary/extreme values that trigger different behavior
+- Each of the \`validValueOptions\` must be the exact type that we provide in "Attributes and Value Types".
 - Be very specific with values. Do not make them ambiguous in any way
 — Do NOT include values that would cause unexpected/unhandled errors.
 - Ensure all values or value ranges that will trigger different rendering behavior are included
@@ -194,6 +218,10 @@ List all key attributes in order from most impactful to least impactful regardin
     {
       "fullPath": "signature[0].user",
       "description": "Controls whether the main form or redirect screen displays",
+      "dependencies": [
+        "signature[0].projectId": "must be a valid project ID for 'user' to have effect"
+      ],
+      "valueType": "object",
       "validValueOptions": ["an empty object {}", "null/undefined"]
     }
   ]
@@ -226,9 +254,20 @@ Each conditional lists it's source and how it is used. This should help you iden
 
 Only return attributes from the "Attributes and Value Types" list — these are the only values we can control. Use the exact \`fullPath\` provided. Use \`functionCallReturnValue\` for function return values. Use \`[]\` for array items (e.g., \`items[]\`).
 
+## Dependencies
+
+If this key attribute is only used if one or more other attributes have specific values, include those dependencies in a \`dependencies\` array.
+
+## Value Type
+
+Should reiterate the type of the attribute (e.g., "string", "object", "array", "boolean", etc.) based on the "Attributes and Value Types" list.
+
+All validValueOptions must be of this type.
+
 ## Valid Value Options
 
-- For \`validValueOptions\`, include boundary/extreme values that trigger different behavior 
+- For \`validValueOptions\`, include boundary/extreme values that trigger different behavior
+- Each of the \`validValueOptions\` must be the exact type that we provide in "Attributes and Value Types".
 - Be very specific with values. Do not make them ambiguous in any way
 — Do NOT include values that would cause unexpected/unhandled errors.
 - Ensure all values or value ranges that will trigger different rendering behavior are included
@@ -243,6 +282,10 @@ List all key attributes in order from most impactful to least impactful using th
     {
       "fullPath": "signature[0].config.enabled",
       "description": "Controls whether the main processing logic runs",
+      "dependencies": [
+        "signature[0].analysisMode": "must be 'full' for 'enabled' to have effect"
+      ],
+      "valueType": "boolean",
       "validValueOptions": ["true", "false"]
     }
   ]

package/analyzer-template/packages/ai/src/lib/generateEntityScenarioData.ts

@@ -11,6 +11,7 @@ import type {
 import validateJson from './validateJson';
 import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
 import { AI, parseJsonSafe } from '~codeyam/ai';
+import transformMockDataToMatchSchema from './transformMockDataToMatchSchema';
 
 const DEFAULT_SCENARIO_NAME = 'Default Scenario';
 
@@ -137,6 +138,16 @@ export async function generateDataForScenario({
       : [],
   });
 
+  // Transform mock data values to match expected schema types
+  // (e.g., LLM might generate array for route params that should be strings)
+  if (scenarioDataWithoutDescription.data?.mockData && structure.dataForMocks) {
+    scenarioDataWithoutDescription.data.mockData =
+      transformMockDataToMatchSchema(
+        scenarioDataWithoutDescription.data.mockData as Record<string, unknown>,
+        structure.dataForMocks as Record<string, unknown>,
+      ) as typeof scenarioDataWithoutDescription.data.mockData;
+  }
+
   const fullScenarioData: ScenarioData = {
     ...scenarioDataWithoutDescription,
     scenarioDescription: scenario?.description ?? '',
@@ -284,9 +295,9 @@ export const generateSystemMessage = (
   const scenarioType = defaultScenario
     ? `## Default Scenario
 Generate COMPLETE, robust data for the entire data structure.
-- Fill ALL fields with realistic values (except error attributes)
+- Fill ALL fields with realistic values (except error attributes and key attributes set to null or undefined)
 - Arrays should have 2-3 items
-- Don't skip nested attributes
+- Don't skip nested attributes unless the key attributes specify a parent attribute should be null or undefined
 - This provides the baseline data for all other scenarios`
     : `## Non-Default Scenario
 Generate ONLY the differences from the default scenario.
@@ -317,8 +328,10 @@ Use for relative dates. Code runs in Node (no browser APIs, no external librarie
 \`\`\`
 Use simple elements only (\`<div>\`, \`<span>\`). No custom components.
 
-## Function Keys
-Preserve function call syntax exactly as written in the structure:
+## Mock Data Keys
+Preserve keys exactly as written in the structure. There are two formats:
+
+### Standard function calls
 \`\`\`json
 {
   "mockData": {
@@ -328,6 +341,18 @@ Preserve function call syntax exactly as written in the structure:
 }
 \`\`\`
 
+### Variable-qualified calls (for multiple calls to the same function)
+When the same function is called multiple times with results stored in different variables, keys use the format \`variableName <- functionName\`:
+\`\`\`json
+{
+  "mockData": {
+    "entityDiffFetcher <- useFetcher": { "data": null, "state": "idle" },
+    "reportFetcher <- useFetcher": { "data": { "reportId": "abc123" }, "state": "idle" }
+  }
+}
+\`\`\`
+This reads as "entityDiffFetcher receives from useFetcher". Each variable gets its own distinct mock data.
+
 ## Response Format
 \`\`\`json
 {

package/analyzer-template/packages/ai/src/lib/generateStatementAnalysis.ts

@@ -4,7 +4,7 @@ import { saveLlmCall } from '~codeyam/aws/dynamodb';
 import generateEntityPropsStructureGenerator from './promptGenerators/generateEntityPropsStructureGenerator';
 import identifyReserved, { ReservedFeature } from './identifyReserved';
 import splitOutsideParentheses from './splitOutsideParentheses';
-import { generateSha, loadStatement, saveStatement } from '~codeyam/supabase';
+import { generateSha, loadStatement, saveStatement } from '~codeyam/database';
 import { ScopeInfo } from './dataStructure/ScopeDataStructure';
 import { AI, parseJsonSafe } from '~codeyam/ai';
 

package/analyzer-template/packages/ai/src/lib/mergeStatements.ts

@@ -12,6 +12,53 @@ export interface Statement {
 }
 
 export default function mergeStatements(statements: Statement[]) {
+  // Debug: Log input statements to understand what we're merging
+  const hasStateStructure = statements.some((s) =>
+    Object.keys(s.structure || {}).some(
+      (k) => k === 'state' || k.includes('state'),
+    ),
+  );
+  const hasStateEquiv = statements.some((s) =>
+    Object.keys(s.equivalentVariables || {}).some(
+      (k) => k === 'state' || k.includes('state'),
+    ),
+  );
+  if (hasStateStructure || hasStateEquiv) {
+    console.log(
+      `[UNION-TYPE] mergeStatements INPUT: ${statements.length} statements`,
+    );
+    statements.forEach((s, i) => {
+      const stateInStructure = Object.entries(s.structure || {}).filter(
+        ([k]) => k === 'state' || k.includes('state'),
+      );
+      const stateInEquiv = Object.entries(s.equivalentVariables || {}).filter(
+        ([k]) => k === 'state' || k.includes('state'),
+      );
+      const sigInEquiv = Object.entries(s.equivalentVariables || {}).filter(
+        ([k, v]) => k === 'state' || v === 'signature[0]',
+      );
+      if (
+        stateInStructure.length > 0 ||
+        stateInEquiv.length > 0 ||
+        sigInEquiv.length > 0
+      ) {
+        console.log(`[UNION-TYPE]   Statement ${i}:`);
+        if (stateInStructure.length > 0)
+          console.log(
+            `[UNION-TYPE]     structure: ${JSON.stringify(Object.fromEntries(stateInStructure))}`,
+          );
+        if (stateInEquiv.length > 0)
+          console.log(
+            `[UNION-TYPE]     equivalentVariables (state): ${JSON.stringify(Object.fromEntries(stateInEquiv))}`,
+          );
+        if (sigInEquiv.length > 0)
+          console.log(
+            `[UNION-TYPE]     equivalentVariables (sig): ${JSON.stringify(Object.fromEntries(sigInEquiv))}`,
+          );
+      }
+    });
+  }
+
   // This should be handled by the AST Analyzer but it currently has a bug
   const ensureFunctionCallReturnValue = (path: string, value: string) => {
     if (path.endsWith(')') && value !== 'function') {
@@ -77,6 +124,15 @@ export default function mergeStatements(statements: Statement[]) {
   ) => {
     if (!mapping[key] || mapping[key] === 'unknown') {
       mapping[key] = value;
+      return;
+    }
+
+    // Prefer union types (containing ' | ') over generic types like "string"
+    const existingIsGeneric =
+      mapping[key] === 'string' || mapping[key] === 'unknown';
+    const newIsUnion = value.includes("'") && value.includes(' | ');
+    if (existingIsGeneric && newIsUnion) {
+      mapping[key] = value;
     }
   };
 
@@ -157,5 +213,53 @@ export default function mergeStatements(statements: Statement[]) {
 
   const llmCalls = statements.map((result) => result.llmCall).filter(Boolean);
 
+  // Propagate more specific types through equivalentVariables
+  // If we have equivalentVariables[A] = B, and structure[A] is more specific than structure[B],
+  // then update structure[B] to match structure[A]
+  // This handles cases like: "state" -> "signature[0]" where "state" has a union type
+
+  // Debug: Log union types in merged structure
+  const unionTypesInStructure = Object.entries(structure).filter(
+    ([_, v]) => typeof v === 'string' && v.includes("'") && v.includes(' | '),
+  );
+  if (unionTypesInStructure.length > 0) {
+    console.log(
+      `[UNION-TYPE] mergeStatements: Found ${unionTypesInStructure.length} union types in merged structure`,
+    );
+    unionTypesInStructure.forEach(([k, v]) =>
+      console.log(`[UNION-TYPE]   structure["${k}"] = ${v}`),
+    );
+    console.log(
+      `[UNION-TYPE] mergeStatements: equivalentVariables = ${JSON.stringify(equivalentVariables)}`,
+    );
+  }
+
+  for (const [source, target] of Object.entries(equivalentVariables) as [
+    string,
+    string,
+  ][]) {
+    const sourceType = structure[source];
+    const targetType = structure[target];
+
+    // Check if source has a more specific type (union type vs generic type)
+    if (sourceType) {
+      const sourceIsUnion =
+        sourceType.includes("'") && sourceType.includes(' | ');
+
+      if (sourceIsUnion) {
+        // Target doesn't exist or is generic - propagate the union type
+        const targetIsGeneric =
+          !targetType || targetType === 'string' || targetType === 'unknown';
+
+        if (targetIsGeneric) {
+          console.log(
+            `[UNION-TYPE] mergeStatements: Propagating "${source}" (${sourceType}) -> "${target}"`,
+          );
+          structure[target] = sourceType;
+        }
+      }
+    }
+  }
+
   return { structure, equivalentVariables, llmCalls };
 }

package/analyzer-template/packages/ai/src/lib/promptGenerators/gatherAttributesMap.ts

@@ -1,4 +1,4 @@
-import { Entity } from '~codeyam/types';
+import { DataStructure } from '~codeyam/types';
 import cleanOutBoundary from '../cleanOutBoundary';
 import {
   joinParenthesesAndArrays,
@@ -65,19 +65,80 @@ function validAttribute(attribute: string) {
   return true;
 }
 
+/**
+ * Gathers attributes from data structures for use in prompts.
+ *
+ * @param isolatedDataStructure - The entity's own data structure (determines which paths to include)
+ * @param mergedDataStructureOrEquivalentVars - Either the merged data structure (with richer types from
+ *   dependent analyses) OR equivalentSignatureVariables for backwards compatibility
+ * @param equivalentSignatureVariablesOrReverse - Either equivalentSignatureVariables OR reverse flag
+ * @param reverseArg - The reverse flag (only used when all 4 args provided)
+ */
 export function gatherAttributesMap(
-  entity: Pick<Entity, 'metadata'>,
-  reverse = false,
+  isolatedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
+  mergedDataStructureOrEquivalentVars?:
+    | Omit<DataStructure, 'equivalentSignatureVariables'>
+    | DataStructure['equivalentSignatureVariables'],
+  equivalentSignatureVariablesOrReverse?:
+    | DataStructure['equivalentSignatureVariables']
+    | boolean,
+  reverseArg?: boolean,
 ) {
+  // Handle backwards compatibility: detect if called with old signature
+  // Old: (mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  // New: (isolatedDataStructure, mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  let mergedDataStructure: Omit<
+    DataStructure,
+    'equivalentSignatureVariables'
+  > | null;
+  let equivalentSignatureVariables: DataStructure['equivalentSignatureVariables'];
+  let reverse: boolean;
+
+  if (
+    mergedDataStructureOrEquivalentVars &&
+    typeof mergedDataStructureOrEquivalentVars === 'object' &&
+    'dependencySchemas' in mergedDataStructureOrEquivalentVars
+  ) {
+    // New signature: (isolated, merged, equivalentVars?, reverse?)
+    mergedDataStructure = mergedDataStructureOrEquivalentVars as Omit<
+      DataStructure,
+      'equivalentSignatureVariables'
+    >;
+    equivalentSignatureVariables =
+      (equivalentSignatureVariablesOrReverse as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse = reverseArg ?? false;
+  } else {
+    // Old signature: (merged, equivalentVars?, reverse?)
+    // Use isolatedDataStructure as both isolated and merged for backwards compatibility
+    mergedDataStructure = null; // Will use isolatedDataStructure for types
+    equivalentSignatureVariables =
+      (mergedDataStructureOrEquivalentVars as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse =
+      (equivalentSignatureVariablesOrReverse as boolean | undefined) ?? false;
+  }
+
   const attributesMap: Record<string, string> = {};
   const associationMap: Record<string, string> = {};
   // Maps internalPath -> full data structure path (e.g., "useDiffModal().diffView")
   const dataStructurePathMap: Record<string, string> = {};
-  const { signatureSchema, equivalentSignatureVariables, dependencySchemas } =
-    entity.metadata.isolatedDataStructure;
-  for (const key in signatureSchema) {
+
+  // Use isolatedDataStructure for paths, but look up types in mergedDataStructure when available
+  const isolatedSignatureSchema = isolatedDataStructure.signatureSchema;
+  const mergedSignatureSchema =
+    mergedDataStructure?.signatureSchema ?? isolatedSignatureSchema;
+  const isolatedDependencySchemas = isolatedDataStructure.dependencySchemas;
+  const mergedDependencySchemas =
+    mergedDataStructure?.dependencySchemas ?? isolatedDependencySchemas;
+
+  // Process signature schema - use isolatedDataStructure keys, but merged types
+  for (const key in isolatedSignatureSchema) {
     const keyParts = splitOutsideParenthesesAndArrays(key);
     if (keyParts[0].startsWith('signature')) {
+      // Use merged type if available, otherwise fall back to isolated type
+      const typeValue =
+        mergedSignatureSchema[key] ?? isolatedSignatureSchema[key];
       const equivalentSignatureVariable =
         equivalentSignatureVariables[keyParts[0]];
       const equivalentSignatureVariableParts = splitOutsideParenthesesAndArrays(
@@ -92,7 +153,7 @@ export function gatherAttributesMap(
           equivalentKey,
           ...keyParts.slice(1),
         ]);
-        attributesMap[equivalentPath] = signatureSchema[key];
+        attributesMap[equivalentPath] = typeValue;
         associationMap[reverse ? equivalentPath : key] = reverse
           ? key
           : equivalentPath;
@@ -100,7 +161,7 @@ export function gatherAttributesMap(
         dataStructurePathMap[equivalentPath] = equivalentPath;
       } else {
         const relativePath = joinParenthesesAndArrays(keyParts.slice(1));
-        attributesMap[relativePath] = signatureSchema[key];
+        attributesMap[relativePath] = typeValue;
         associationMap[reverse ? relativePath : key] = reverse
           ? key
           : relativePath;
@@ -110,25 +171,34 @@ export function gatherAttributesMap(
     }
   }
 
-  for (const filePath in dependencySchemas) {
-    for (const entityName in dependencySchemas[filePath]) {
-      const returnValueDataStructure =
-        dependencySchemas[filePath][entityName].returnValueSchema ?? {};
+  // Process dependency schemas - iterate through isolatedDependencySchemas (for which paths to include)
+  // but use mergedDependencySchemas for types (richer type information)
+  for (const filePath in isolatedDependencySchemas) {
+    for (const entityName in isolatedDependencySchemas[filePath]) {
+      // Get the isolated return value schema (determines which paths exist)
+      const isolatedReturnValueSchema =
+        isolatedDependencySchemas[filePath][entityName].returnValueSchema ?? {};
+
+      // Get the merged return value schema (for richer types)
+      const mergedReturnValueSchema =
+        mergedDependencySchemas?.[filePath]?.[entityName]?.returnValueSchema ??
+        isolatedReturnValueSchema;
 
-      // First pass: collect all function paths
+      // First pass: collect all function paths from merged schema (for broader coverage)
       const functionPaths: string[] = [];
-      for (const path in returnValueDataStructure) {
-        if (returnValueDataStructure[path] === 'function') {
+      for (const path in mergedReturnValueSchema) {
+        if (mergedReturnValueSchema[path] === 'function') {
           functionPaths.push(path);
         }
       }
 
-      // Second pass: process all paths
-      for (const path in returnValueDataStructure) {
+      // Second pass: process paths from merged schema, but only include paths that
+      // are rooted in an isolated path (i.e., isolatedDataStructure knows about this dependency)
+      for (const path in mergedReturnValueSchema) {
         const pathParts = splitOutsideParenthesesAndArrays(path);
         if (pathParts.length < 2) continue;
 
-        if (returnValueDataStructure[path] === 'function') {
+        if (mergedReturnValueSchema[path] === 'function') {
           continue;
         }
 
@@ -176,7 +246,7 @@ export function gatherAttributesMap(
               const relativePath = path;
               if (!validAttribute(relativePath)) continue;
 
-              attributesMap[relativePath] = returnValueDataStructure[path];
+              attributesMap[relativePath] = mergedReturnValueSchema[path];
               associationMap[reverse ? relativePath : path] = reverse
                 ? path
                 : relativePath;
@@ -194,7 +264,8 @@ export function gatherAttributesMap(
         // Normalize the path for internal use (e.g., ['*'] -> '*')
         const relativePath = normalizePathForInternalUse(rawRelativePath);
 
-        attributesMap[relativePath] = returnValueDataStructure[path];
+        // Use the type from mergedReturnValueSchema
+        attributesMap[relativePath] = mergedReturnValueSchema[path];
         associationMap[reverse ? relativePath : path] = reverse
           ? path
           : relativePath;

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -1,4 +1,5 @@
 import {
+  DataStructure,
   Entity,
   Scenario,
   ReadonlyAnalysisMap,
@@ -8,6 +9,7 @@ import gatherRelevantDependentKeyAttributes from '../gatherRelevantDependentKeyA
 
 interface GenerateChangesEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'name' | 'code' | 'metadata'>;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
   keyAttributes: Analysis['metadata']['keyAttributes'];
   addedKeyAttributes: Analysis['metadata']['keyAttributes'];
   removedKeyAttributes: Analysis['metadata']['keyAttributes'];
@@ -20,6 +22,7 @@ interface GenerateChangesEntityScenariosGeneratorArgs {
 
 export default function generateChangesEntityScenariosGenerator({
   entity,
+  mergedDataStructure,
   keyAttributes,
   addedKeyAttributes,
   removedKeyAttributes,
@@ -30,7 +33,11 @@ export default function generateChangesEntityScenariosGenerator({
   changedDataStructureFields = [],
 }: GenerateChangesEntityScenariosGeneratorArgs) {
   const relevantDependentKeyAttributesFlat =
-    gatherRelevantDependentKeyAttributes(entity, dependentAnalyses);
+    gatherRelevantDependentKeyAttributes(
+      entity,
+      mergedDataStructure,
+      dependentAnalyses,
+    );
 
   // Restructure flat array into nested format: { [filePath]: { [entityName]: KeyAttribute[] } }
   const relevantDependentKeyAttributes: Record<
@@ -58,6 +65,9 @@ export default function generateChangesEntityScenariosGenerator({
       localVariable: ka.internalPath,
       description: ka.description,
       validValueOptions: ka.validValueOptions,
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
     }));
 
   const addedSection =
@@ -122,6 +132,9 @@ ${JSON.stringify(
           localVariable: ka.path || ka.internalPath,
           description: ka.description,
           validValueOptions: ka.validValueOptions,
+          // Include new fields when present
+          ...(ka.valueType && { valueType: ka.valueType }),
+          ...(ka.dependencies && { dependencies: ka.dependencies }),
         }));
         return entityAcc;
       },

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenariosGenerator.ts

@@ -25,6 +25,9 @@ export default function generateEntityScenariosGenerator({
       localVariable: ka.internalPath,
       description: ka.description,
       validValueOptions: ka.validValueOptions,
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
     })),
     null,
     2,
@@ -44,6 +47,9 @@ ${JSON.stringify(
     forDependency: ka.dependentEntityName,
     description: ka.description,
     validValueOptions: ka.validValueOptions,
+    // Include new fields when present
+    ...(ka.valueType && { valueType: ka.valueType }),
+    ...(ka.dependencies && { dependencies: ka.dependencies }),
   })),
   null,
   2,