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

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

@@ -0,0 +1,391 @@
+import { JsonTypeDefinition } from '~codeyam/types';
+
+/**
+ * Simplify verbose function call keys for LLM consumption.
+ *
+ * The static analysis generates keys that include entire function call signatures
+ * with all arguments, including multi-line callback bodies. For example:
+ *
+ * ```
+ * "useQuery({ id: Number(id), pagination: debouncedPagination, onSuccess: async (quote) => { ...30 lines... } })"
+ * ```
+ *
+ * These verbose keys confuse the LLM and cause it to miss generating data for some keys.
+ * This function simplifies keys to just the essential parts:
+ *
+ * ```
+ * "useQuery({ id, pagination, onSuccess: () => <truncated> })"
+ * ```
+ *
+ * The reconcileMockDataKeys function already does fuzzy matching, so the LLM's
+ * simplified response keys will still match back to the original verbose keys.
+ */
+export default function simplifyKeysForLLM(
+  data: JsonTypeDefinition,
+): JsonTypeDefinition {
+  if (typeof data !== 'object' || data === null) {
+    return data;
+  }
+
+  const result: JsonTypeDefinition = {};
+
+  for (const key of Object.keys(data)) {
+    const simplifiedKey = simplifyFunctionCallKey(key);
+    const value = data[key];
+
+    // Recursively simplify nested objects
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      result[simplifiedKey] = simplifyKeysForLLM(value as JsonTypeDefinition);
+    } else if (Array.isArray(value)) {
+      // For arrays, recursively simplify each object element
+      result[simplifiedKey] = value.map((item) =>
+        typeof item === 'object' && item !== null && !Array.isArray(item)
+          ? simplifyKeysForLLM(item as JsonTypeDefinition)
+          : item,
+      ) as JsonTypeDefinition[];
+    } else {
+      result[simplifiedKey] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Simplify a single function call key.
+ *
+ * Rules:
+ * 1. If key doesn't look like a function call, return as-is
+ * 2. For function calls with object arguments:
+ *    - Keep property names
+ *    - Replace complex values with simplified versions
+ *    - Replace callbacks with () => ...
+ * 3. Cap total length at MAX_KEY_LENGTH
+ */
+function simplifyFunctionCallKey(key: string): string {
+  // If it doesn't look like a function call, return as-is
+  if (!key.includes('(')) {
+    return key;
+  }
+
+  // Extract function name and arguments
+  const funcNameMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/);
+  if (!funcNameMatch) {
+    return key;
+  }
+
+  const funcName = funcNameMatch[1];
+  const argsStart = key.indexOf('(');
+  const argsContent = key.slice(argsStart + 1, -1); // Remove outer parens
+
+  // If args are empty or very short, return as-is
+  if (argsContent.trim().length < 50) {
+    return key;
+  }
+
+  // Parse and simplify the arguments
+  const simplifiedArgs = simplifyArguments(argsContent);
+  const simplified = `${funcName}(${simplifiedArgs})`;
+
+  // Cap length - use <truncated> instead of ... to prevent LLMs from
+  // interpreting it as a fill-in placeholder (Issue #14)
+  const MAX_KEY_LENGTH = 150;
+  if (simplified.length > MAX_KEY_LENGTH) {
+    return simplified.slice(0, MAX_KEY_LENGTH - 11) + '<truncated>';
+  }
+
+  return simplified;
+}
+
+/**
+ * Simplify function call arguments.
+ *
+ * Handles multiple arguments separated by commas, where each argument
+ * could be an object literal, a simple value, or a complex expression.
+ */
+function simplifyArguments(argsContent: string): string {
+  const trimmed = argsContent.trim();
+
+  // Split arguments at top-level commas (not inside nested structures)
+  const args = splitTopLevelArguments(trimmed);
+
+  const simplifiedArgs = args.map((arg) => {
+    const argTrimmed = arg.trim();
+
+    // Check if it's an object literal (starts with {)
+    if (argTrimmed.startsWith('{')) {
+      return simplifyObjectLiteral(argTrimmed);
+    }
+
+    // For non-object arguments, just truncate if needed
+    // Use <truncated> instead of ... to prevent LLMs from interpreting as fill-in
+    if (argTrimmed.length > 30) {
+      return argTrimmed.slice(0, 19) + '<truncated>';
+    }
+
+    return argTrimmed;
+  });
+
+  return simplifiedArgs.join(', ');
+}
+
+/**
+ * Split arguments at top-level commas, respecting nested braces/parens.
+ */
+function splitTopLevelArguments(argsContent: string): string[] {
+  const args: string[] = [];
+  let current = '';
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  for (let i = 0; i < argsContent.length; i++) {
+    const char = argsContent[i];
+    const prevChar = i > 0 ? argsContent[i - 1] : '';
+
+    // Handle string boundaries
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+
+    if (!inString) {
+      if (char === '{' || char === '(' || char === '[') {
+        depth++;
+      } else if (char === '}' || char === ')' || char === ']') {
+        depth--;
+      } else if (char === ',' && depth === 0) {
+        // End of argument
+        if (current.trim()) {
+          args.push(current.trim());
+        }
+        current = '';
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  // Don't forget the last argument
+  if (current.trim()) {
+    args.push(current.trim());
+  }
+
+  return args;
+}
+
+/**
+ * Simplify an object literal, keeping property names but simplifying values.
+ */
+function simplifyObjectLiteral(objStr: string): string {
+  // Extract property names and their values
+  const properties = extractObjectProperties(objStr);
+
+  if (properties.length === 0) {
+    return '{ }';
+  }
+
+  const simplifiedProps = properties.map(({ name, value }) => {
+    const simplifiedValue = simplifyPropertyValue(value);
+    // If value is same as name (shorthand), just use name
+    if (simplifiedValue === name) {
+      return name;
+    }
+    return `${name}: ${simplifiedValue}`;
+  });
+
+  return `{ ${simplifiedProps.join(', ')} }`;
+}
+
+/**
+ * Extract property names and values from an object literal string.
+ */
+function extractObjectProperties(
+  objStr: string,
+): Array<{ name: string; value: string }> {
+  const properties: Array<{ name: string; value: string }> = [];
+
+  // Remove outer braces and trim
+  let content = objStr.trim();
+  if (content.startsWith('{')) content = content.slice(1);
+  if (content.endsWith('}')) content = content.slice(0, -1);
+  content = content.trim();
+
+  // Parse properties, handling nested structures
+  let current = '';
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    const prevChar = i > 0 ? content[i - 1] : '';
+
+    // Handle string boundaries
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+
+    if (!inString) {
+      if (char === '{' || char === '(' || char === '[') {
+        depth++;
+      } else if (char === '}' || char === ')' || char === ']') {
+        depth--;
+      } else if (char === ',' && depth === 0) {
+        // End of property
+        const prop = parseProperty(current.trim());
+        if (prop) properties.push(prop);
+        current = '';
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  // Don't forget the last property
+  if (current.trim()) {
+    const prop = parseProperty(current.trim());
+    if (prop) properties.push(prop);
+  }
+
+  return properties;
+}
+
+/**
+ * Parse a single property string into name and value.
+ */
+function parseProperty(
+  propStr: string,
+): { name: string; value: string } | null {
+  // Handle shorthand properties (just a name)
+  const shorthandMatch = propStr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
+  if (shorthandMatch) {
+    return { name: shorthandMatch[1], value: shorthandMatch[1] };
+  }
+
+  // Handle name: value
+  const colonIndex = findPropertyColon(propStr);
+  if (colonIndex === -1) {
+    return null;
+  }
+
+  const name = propStr.slice(0, colonIndex).trim();
+  const value = propStr.slice(colonIndex + 1).trim();
+
+  // Clean up property name (remove quotes if present)
+  const cleanName = name.replace(/^['"]|['"]$/g, '');
+
+  return { name: cleanName, value };
+}
+
+/**
+ * Find the colon that separates property name from value.
+ * Must handle cases like { 'key': value } and { key: value }
+ */
+function findPropertyColon(propStr: string): number {
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  for (let i = 0; i < propStr.length; i++) {
+    const char = propStr[i];
+    const prevChar = i > 0 ? propStr[i - 1] : '';
+
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+
+    if (!inString) {
+      if (char === '{' || char === '(' || char === '[') {
+        depth++;
+      } else if (char === '}' || char === ')' || char === ']') {
+        depth--;
+      } else if (char === ':' && depth === 0) {
+        return i;
+      }
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Simplify a property value.
+ */
+function simplifyPropertyValue(value: string): string {
+  const trimmed = value.trim();
+
+  // If it's a simple identifier, return as-is
+  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
+    return trimmed;
+  }
+
+  // If it's a simple literal (number, boolean, null, undefined), return as-is
+  if (/^(true|false|null|undefined|\d+(\.\d+)?)$/.test(trimmed)) {
+    return trimmed;
+  }
+
+  // If it's a short string literal, return as-is
+  if (
+    (trimmed.startsWith('"') || trimmed.startsWith("'")) &&
+    trimmed.length < 30
+  ) {
+    return trimmed;
+  }
+
+  // If it looks like a function/arrow function, simplify
+  // Use <truncated> instead of ... to prevent LLMs from interpreting as fill-in
+  if (
+    trimmed.startsWith('function') ||
+    trimmed.startsWith('async function') ||
+    trimmed.includes('=>') ||
+    (trimmed.startsWith('(') && trimmed.includes('=>'))
+  ) {
+    return '() => <truncated>';
+  }
+
+  // If it's an object literal, recursively simplify
+  if (trimmed.startsWith('{')) {
+    const inner = simplifyObjectLiteral(trimmed);
+    if (inner.length > 50) {
+      return '{ <truncated> }';
+    }
+    return inner;
+  }
+
+  // If it's an array, simplify
+  // Use <truncated> instead of ... to prevent LLMs from interpreting as fill-in
+  if (trimmed.startsWith('[')) {
+    return '[<truncated>]';
+  }
+
+  // For complex expressions, extract the first identifier or truncate
+  // Use <truncated> instead of ... to prevent LLMs from interpreting as fill-in
+  const identMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  if (identMatch && trimmed.length > 30) {
+    return identMatch[1] + '<truncated>';
+  }
+
+  // Truncate long values
+  if (trimmed.length > 30) {
+    return trimmed.slice(0, 19) + '<truncated>';
+  }
+
+  return trimmed;
+}