@codeyam/codeyam-cli 0.1.0-staging.dd216e0 → 0.1.0-staging.e090cb3

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/convertNullToUndefinedBySchema.ts

@@ -0,0 +1,98 @@
+/**
+ * Converts null values to undefined (removes them) based on schema type constraints.
+ *
+ * When the LLM generates mock data, it uses `null` to represent "no value" because
+ * JSON doesn't support `undefined`. However, TypeScript types like `string | undefined`
+ * don't accept `null`.
+ *
+ * This function traverses data and schema together:
+ * - If schema type is "T | undefined" (but NOT "T | null"), convert null → undefined (delete key)
+ * - If schema type includes "null" (e.g., "T | null" or "T | null | undefined"), preserve null
+ * - If field not in schema, preserve as-is
+ *
+ * @param data The data object with potential null values
+ * @param schema The schema describing expected types
+ * @returns The data with null→undefined conversions applied (mutates original)
+ */
+export default function convertNullToUndefinedBySchema<T>(
+  data: T,
+  schema: unknown,
+): T {
+  // Handle null/undefined data
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  // Only process objects
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    // For arrays, the schema should be an array with one element describing the item type
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = convertNullToUndefinedBySchema(data[i], itemSchema);
+    }
+    return data;
+  }
+
+  // Handle objects
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+
+    if (value === null) {
+      // Check if schema allows null
+      if (shouldConvertNullToUndefined(fieldSchema)) {
+        // Delete the key (converts null to undefined)
+        delete dataObj[key];
+      }
+      // If schema allows null, preserve it
+    } else if (typeof value === 'object' && value !== null) {
+      // Recursively process nested objects/arrays
+      convertNullToUndefinedBySchema(value, fieldSchema);
+    }
+  }
+
+  return data;
+}
+
+/**
+ * Determines if a null value should be converted to undefined based on schema type.
+ *
+ * @param fieldSchema The schema type string or object for the field
+ * @returns true if null should be converted to undefined, false if null should be preserved
+ */
+function shouldConvertNullToUndefined(fieldSchema: unknown): boolean {
+  // If no schema for this field, preserve null (be conservative)
+  if (fieldSchema === undefined || fieldSchema === null) {
+    return false;
+  }
+
+  // If schema is a string type definition, check if it allows null
+  if (typeof fieldSchema === 'string') {
+    // Schema types that include "null" should preserve null values
+    // e.g., "string | null", "number | null | undefined", "null"
+    const allowsNull = fieldSchema.includes('null');
+    const allowsUndefined = fieldSchema.includes('undefined');
+
+    // If type allows undefined but NOT null, convert null to undefined
+    // e.g., "string | undefined" → convert null to undefined
+    // e.g., "string | null" → preserve null
+    // e.g., "string | null | undefined" → preserve null
+    if (allowsUndefined && !allowsNull) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // If schema is an object or array, it's a nested structure
+  // Don't convert the container itself, just recurse into it
+  return false;
+}

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/convertTypeAnnotationsToValues.ts

@@ -0,0 +1,179 @@
+/**
+ * Converts type annotation strings that appear as values in mockData to actual values.
+ *
+ * The LLM sometimes echoes the schema type annotation as the actual value.
+ * For example, if the schema says { filePath: "string | undefined" },
+ * the LLM might return { filePath: "string | undefined" } instead of
+ * generating an actual value like { filePath: "/path/to/file.tsx" }.
+ *
+ * This causes runtime errors when the code tries to use these "values"
+ * as actual data (e.g., calling .length on the string "string | undefined").
+ *
+ * This function detects type annotation strings and converts them to
+ * appropriate default values:
+ * - "string" → ""
+ * - "number" → 0
+ * - "boolean" → false
+ * - "function" → () => {}
+ * - "Date" → new Date()
+ * - "T | undefined" → undefined
+ * - "T | null" → null
+ * - "string[]" → []
+ */
+
+// Pattern to detect if a string looks like a TypeScript type annotation
+// This matches common type patterns:
+// - Primitive types: string, number, boolean, function, Date, object, any, unknown
+// - Union types: string | undefined, number | null, T | null | undefined
+// - Array types: string[], number[], T[]
+// - Optional types: T?
+const TYPE_ANNOTATION_PATTERN =
+  /^(string|number|boolean|function|Date|object|any|unknown|void|never|null|undefined|array)(\s*\|\s*(string|number|boolean|function|Date|object|any|unknown|void|never|null|undefined|array))*(\[\])?$/i;
+
+/**
+ * Check if a string value looks like a TypeScript type annotation.
+ */
+function isTypeAnnotation(value: string): boolean {
+  if (typeof value !== 'string') return false;
+
+  const trimmed = value.trim();
+
+  // Quick check: type annotations are typically short
+  if (trimmed.length > 100) return false;
+
+  // Check against the pattern
+  if (TYPE_ANNOTATION_PATTERN.test(trimmed)) return true;
+
+  // Also check for common patterns that the regex might miss
+  const commonTypePatterns = [
+    'string',
+    'number',
+    'boolean',
+    'function',
+    'object',
+    'array',
+    'Date',
+    'any',
+    'unknown',
+    'void',
+    'never',
+    'null',
+    'undefined',
+    'string | undefined',
+    'string | null',
+    'string | null | undefined',
+    'number | undefined',
+    'number | null',
+    'number | null | undefined',
+    'boolean | undefined',
+    'boolean | null',
+    'boolean | null | undefined',
+    'Date | undefined',
+    'Date | null',
+    'function | undefined',
+    'object | undefined',
+    'object | null',
+    'string[]',
+    'number[]',
+    'boolean[]',
+    'any[]',
+    'string | number',
+    'string | number | undefined',
+  ];
+
+  if (commonTypePatterns.includes(trimmed)) return true;
+
+  // Check for arrow function type annotations like "() => void", "(event: MouseEvent) => void"
+  // These contain '=>' but the body is a type keyword, not a JS expression
+  if (trimmed.includes('=>')) {
+    const arrowIndex = trimmed.indexOf('=>');
+    const body = trimmed.slice(arrowIndex + 2).trim();
+    if (
+      /^(void|string|number|boolean|any|unknown|never|null|undefined|object|Date|Promise<\w+>)$/i.test(
+        body,
+      )
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Convert a type annotation string to an appropriate default value.
+ */
+function typeAnnotationToValue(typeAnnotation: string): unknown {
+  const trimmed = typeAnnotation.trim().toLowerCase();
+
+  // Handle undefined types first (they take precedence)
+  if (trimmed.includes('| undefined') || trimmed.includes('undefined |')) {
+    return undefined;
+  }
+
+  // Handle null types
+  if (trimmed.includes('| null') || trimmed.includes('null |')) {
+    return null;
+  }
+
+  // Handle array types
+  if (trimmed.endsWith('[]') || trimmed === 'array') {
+    return [];
+  }
+
+  // Handle arrow function type annotations like "() => void"
+  if (trimmed.includes('=>')) return () => {};
+
+  // Handle primitive types
+  if (trimmed === 'string') return '';
+  if (trimmed === 'number') return 0;
+  if (trimmed === 'boolean') return false;
+  if (trimmed === 'function') return () => {};
+  if (trimmed === 'date') return new Date();
+  if (trimmed === 'object') return {};
+  if (trimmed === 'null') return null;
+  if (trimmed === 'undefined') return undefined;
+  if (trimmed === 'any' || trimmed === 'unknown') return undefined;
+  if (trimmed === 'void' || trimmed === 'never') return undefined;
+
+  // Handle union types - prefer the first concrete type
+  if (trimmed.includes(' | ')) {
+    const parts = trimmed.split(' | ').map((p) => p.trim());
+    for (const part of parts) {
+      if (part === 'string') return '';
+      if (part === 'number') return 0;
+      if (part === 'boolean') return false;
+    }
+  }
+
+  // Fallback: return undefined for unknown type patterns
+  return undefined;
+}
+
+/**
+ * Recursively convert type annotation strings to values in a mockData object.
+ * Mutates the object in place.
+ */
+export default function convertTypeAnnotationsToValues(
+  mockData: Record<string, unknown>,
+): void {
+  for (const [key, value] of Object.entries(mockData)) {
+    if (typeof value === 'string' && isTypeAnnotation(value)) {
+      mockData[key] = typeAnnotationToValue(value);
+    } else if (Array.isArray(value)) {
+      // Recursively process array elements
+      for (const item of value) {
+        if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+          convertTypeAnnotationsToValues(item as Record<string, unknown>);
+        }
+      }
+    } else if (
+      value !== null &&
+      typeof value === 'object' &&
+      !Array.isArray(value)
+    ) {
+      // Recursively process nested objects
+      convertTypeAnnotationsToValues(value as Record<string, unknown>);
+    }
+  }
+}

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/deduplicateFunctionSchemas.ts

@@ -77,42 +77,52 @@ export default function deduplicateFunctionSchemas(
 
       // If multiple variants with arguments exist, find the one with the most robust structure
       if (withArgs.length > 1) {
-        // Count the number of related schema keys for each variant
-        const variantDepths = withArgs.map((variant) => {
-          // Find the end of the function call (the closing parenthesis)
+        // Pre-compute function call prefixes for all variants
+        const variantPrefixes = withArgs.map((variant) => {
           const closingParenIndex = variant.lastIndexOf(')');
-          const functionCallPrefix =
-            closingParenIndex > -1
-              ? variant.slice(0, closingParenIndex + 1)
-              : variant;
-
-          const relatedKeys = Object.keys(schema).filter((k) => {
-            // Check if this key is a child of the variant (starts with the function call)
-            return (
-              k.startsWith(functionCallPrefix + '.') ||
-              k.startsWith(functionCallPrefix + '[')
-            );
-          });
-
           return {
             key: variant,
-            depth: relatedKeys.length,
-            maxDepth: Math.max(
-              0,
-              ...relatedKeys.map((k) => {
-                // Count the nesting depth by counting dots and brackets after the variant
-                const remaining = k.slice(functionCallPrefix.length);
-                return (
-                  (remaining.match(/\./g) || []).length +
-                  (remaining.match(/\[/g) || []).length
-                );
-              }),
-            ),
+            prefix:
+              closingParenIndex > -1
+                ? variant.slice(0, closingParenIndex + 1)
+                : variant,
+            depth: 0,
+            maxDepth: 0,
           };
         });
 
+        // Single pass through schema keys to count related keys for ALL variants at once.
+        // This is O(schemaSize × variants) but done in one pass instead of
+        // O(variants × schemaSize) with separate passes per variant.
+        const schemaKeys = Object.keys(schema);
+        for (const k of schemaKeys) {
+          for (const variantInfo of variantPrefixes) {
+            // Check if key starts with prefix followed by . or [
+            const prefixLen = variantInfo.prefix.length;
+            if (k.length > prefixLen) {
+              const nextChar = k[prefixLen];
+              if (
+                (nextChar === '.' || nextChar === '[') &&
+                k.startsWith(variantInfo.prefix)
+              ) {
+                variantInfo.depth++;
+                // Count nesting depth by counting . and [ characters (faster than regex)
+                const remaining = k.slice(prefixLen);
+                let nestingDepth = 0;
+                for (let i = 0; i < remaining.length; i++) {
+                  const c = remaining[i];
+                  if (c === '.' || c === '[') nestingDepth++;
+                }
+                if (nestingDepth > variantInfo.maxDepth) {
+                  variantInfo.maxDepth = nestingDepth;
+                }
+              }
+            }
+          }
+        }
+
         // Sort by depth (number of related keys) and then by max depth (nesting level)
-        variantDepths.sort((a, b) => {
+        variantPrefixes.sort((a, b) => {
           if (b.depth !== a.depth) {
             return b.depth - a.depth;
           }
@@ -120,7 +130,7 @@ export default function deduplicateFunctionSchemas(
         });
 
         // Keep the one with the most robust structure, remove others
-        const keepVariant = variantDepths[0].key;
+        const keepVariant = variantPrefixes[0].key;
         withArgs.forEach((variant) => {
           if (variant !== keepVariant) {
             keysToRemove.add(variant);