@codeyam/codeyam-cli 0.1.0-staging.c90f8c9 → 0.1.0-staging.c9dc00c

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);