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

package/analyzer-template/project/updateCommitBackgroundJob.ts

@@ -1,4 +1,4 @@
-import { updateBackgroundJobProgress } from '~codeyam/supabase';
+import { updateBackgroundJobProgress } from '~codeyam/database';
 import { BackgroundJob } from '~codeyam/types';
 export default async function updateCommitBackgroundJob(
   backgroundJob: BackgroundJob,

package/analyzer-template/project/utils/errorHandling.ts

@@ -1,6 +1,6 @@
 import { Analysis, Scenario } from '~codeyam/types';
 import emailErrorReport from '../emailErrorReport';
-import { updateFreshAnalysisStatus } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus } from '~codeyam/database';
 
 export async function recordErrorMessageForScenario(
   analysis: Analysis,

package/analyzer-template/project/writeMockDataTsx.ts

@@ -101,16 +101,25 @@ const shouldBeMap = (mockKey: string, mergedDataStructure: any): boolean => {
 };
 
 /**
- * Normalize a function call key by stripping arguments and type parameters.
+ * Normalize a function call key by stripping arguments and type parameters,
+ * but preserving variable qualifiers (::variableName suffix).
  * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" -> "useLastLogLine()"
  * e.g., "useLoaderData<typeof loader>()" -> "useLoaderData()"
+ * e.g., "useFetcher()::entityDiffFetcher" -> "useFetcher()::entityDiffFetcher" (preserved)
+ * e.g., "useFetcher<T>()::entityDiffFetcher" -> "useFetcher()::entityDiffFetcher"
  */
 const normalizeKey = (key: string): string => {
-  if (key.endsWith(')') && key.includes('(')) {
+  // Check for variable qualifier (::variableName)
+  const qualifierMatch = key.match(/::[a-zA-Z_][a-zA-Z0-9_]*$/);
+  const qualifier = qualifierMatch ? qualifierMatch[0] : '';
+  const keyWithoutQualifier = qualifier ? key.slice(0, -qualifier.length) : key;
+
+  // Check if key ends with ) - indicating a function call (after removing qualifier)
+  if (keyWithoutQualifier.endsWith(')') && keyWithoutQualifier.includes('(')) {
     // Strip arguments: "foo(a, b)" -> "foo()"
-    const normalized = key.split('(')[0] + '()';
+    const normalized = keyWithoutQualifier.split('(')[0] + '()';
     // Strip type parameters: "foo<T>()" -> "foo()"
-    return cleanOutTypes(normalized);
+    return cleanOutTypes(normalized) + qualifier;
   }
   return key;
 };
@@ -162,11 +171,46 @@ function extractAllKeys(obj: JsonTypeDefinition | undefined): string[] {
   return keys;
 }
 
+/**
+ * Bare type markers that indicate a function was detected but has no actual return data.
+ * These should be filtered out of mock data output since they're just type hints.
+ */
+const BARE_TYPE_MARKERS = ['function', 'async-function'];
+
+/**
+ * Check if a value is a bare function type marker that should be filtered out.
+ * These markers indicate the LLM detected a function but couldn't generate meaningful mock data.
+ *
+ * Also catches TypeScript union types containing function, like:
+ * - "function | null"
+ * - "function | undefined"
+ * - "async-function | null"
+ */
+const isBareTypeMarker = (value: unknown): boolean => {
+  if (typeof value !== 'string') return false;
+
+  // Check for exact bare type markers
+  if (BARE_TYPE_MARKERS.includes(value)) return true;
+
+  // Check for TypeScript union types containing function type markers
+  // e.g., "function | null", "function | undefined", "async-function | null"
+  if (value.includes('|')) {
+    const parts = value.split('|').map((p) => p.trim());
+    // If any part is a bare type marker, treat the whole thing as a type marker
+    return parts.some((part) => BARE_TYPE_MARKERS.includes(part));
+  }
+
+  return false;
+};
+
 /**
  * Normalize mock data by merging entries that have the same normalized function name.
  * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" and
  *       "useLastLogLine(projectSlug, currentRunActive)" both become "useLastLogLine()"
  * Their values are deep-merged to ensure all attributes are accounted for.
+ *
+ * Also filters out bare function type markers like "validateInputs()": "function"
+ * which are just type hints without actual mock data.
  */
 const normalizeMockData = (
   mockData: Record<string, unknown>,
@@ -183,16 +227,40 @@ const normalizeMockData = (
     keyMapping.get(normKey)!.push(key);
   }
 
+  // Helper to check if a value is an empty object
+  const isEmptyObject = (value: unknown): boolean => {
+    return (
+      value !== null &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Object.keys(value as object).length === 0
+    );
+  };
+
   // Second pass: merge values for duplicate normalized keys
   for (const [normKey, originalKeys] of keyMapping) {
     if (originalKeys.length === 1) {
       // No duplicates, use the original key (may be normalized or not based on safeString)
-      normalized[normKey] = mockData[originalKeys[0]];
+      const value = mockData[originalKeys[0]];
+      // Skip bare type markers like "function" or "async-function"
+      if (isBareTypeMarker(value)) {
+        continue;
+      }
+      // Skip empty objects - these cause "Objects are not valid as a React child" errors
+      // when mock functions return them (e.g., CheckCircle2() from lucide-react)
+      if (isEmptyObject(value)) {
+        continue;
+      }
+      normalized[normKey] = value;
     } else {
       // Multiple keys normalize to the same value - merge them
       let mergedValue: unknown = {};
       for (const origKey of originalKeys) {
         const value = mockData[origKey];
+        // Skip bare type markers when merging
+        if (isBareTypeMarker(value)) {
+          continue;
+        }
         if (
           value &&
           typeof value === 'object' &&
@@ -210,7 +278,17 @@ const normalizeMockData = (
           mergedValue = value;
         }
       }
-      normalized[normKey] = mergedValue;
+      // Only add if we have actual data (not just filtered type markers)
+      if (
+        mergedValue !== undefined &&
+        !isBareTypeMarker(mergedValue) &&
+        !(
+          typeof mergedValue === 'object' &&
+          Object.keys(mergedValue as object).length === 0
+        )
+      ) {
+        normalized[normKey] = mergedValue;
+      }
     }
   }
 
@@ -248,8 +326,30 @@ const jsonToCode = (
       // e.g., submit({ a }) and submit({ b }) should both become "submit" once
       const seenNormalizedFuncNames = new Set<string>();
 
+      // Pre-scan to identify plain keys that have function-call versions
+      // These plain keys should be skipped because the function-call version
+      // will be normalized to the same key name
+      // e.g., if both "push" and "push(`/path`)" exist, skip the plain "push"
+      const plainKeysWithFunctionCallVersions = new Set<string>();
       for (const key of Object.keys(jsonObj)) {
-        if (jsonObj[key] === undefined || jsonObj[key] === null) continue;
+        if (key.includes('(') && key.endsWith(')')) {
+          const funcName = key.split('(')[0];
+          // Check if a plain key with this name exists
+          if (funcName in jsonObj && !funcName.includes('(')) {
+            plainKeysWithFunctionCallVersions.add(funcName);
+          }
+        }
+      }
+
+      for (const key of Object.keys(jsonObj)) {
+        if (jsonObj[key] === undefined) continue;
+
+        // Preserve explicit null values - components check `value !== null`
+        // to distinguish "not loaded" (undefined) from "explicitly null"
+        if (jsonObj[key] === null) {
+          keyStrings.push(`${levelSpacing}"${safeString(key, level)}": null`);
+          continue;
+        }
 
         if (Array.isArray(jsonObj[key])) {
           if (key === '~~codeyam-jsx~~') {
@@ -422,6 +522,17 @@ const jsonToCode = (
             if (seenNormalizedFuncNames.has(funcName)) {
               continue;
             }
+
+            // Skip TypeScript union type markers like "function | null" - these are type hints
+            // that would produce invalid JavaScript if output as-is.
+            // Note: We only skip UNION types here (containing '|'), not bare 'function'
+            // because bare 'function' is transformed to () => {} below.
+            // Note: This must come BEFORE seenNormalizedFuncNames.add() so that
+            // if another key with the same funcName has actual data, it can be used.
+            if (stringValue.includes('|') && isBareTypeMarker(stringValue)) {
+              continue;
+            }
+
             seenNormalizedFuncNames.add(funcName);
 
             // Check if the string value looks like a function expression
@@ -459,11 +570,34 @@ const jsonToCode = (
               `${levelSpacing}"${safeString(funcName, level)}": ${outputValue}`,
             );
           } else {
+            // Skip plain keys that have function-call versions (at the same nesting level where
+            // function-call keys get normalized). The function-call version will be output instead.
+            // e.g., if both "push" and "push(`/path`)" exist, skip "push" - the other normalizes to "push"
+            if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+              console.log(
+                `CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`,
+              );
+              continue;
+            }
+            // Skip bare type markers like "function", "function | null", etc.
+            // For plain keys (not function signatures), these are just type hints
+            // that would produce invalid JavaScript if output as-is.
+            if (isBareTypeMarker(stringValue)) {
+              continue;
+            }
             keyStrings.push(
               `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
             );
           }
         } else {
+          // Skip plain keys that have function-call versions (at the same nesting level where
+          // function-call keys get normalized)
+          if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+            console.log(
+              `CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`,
+            );
+            continue;
+          }
           keyStrings.push(
             `${levelSpacing}"${safeString(key, level)}": ${safeString(String(jsonObj[key]), level)}`,
           );
@@ -638,13 +772,44 @@ function serialize(obj) {
         
         // Handle functions
         if (typeof value === 'function') {
-            const fnStr = value.toString();
+            let fnStr;
+            try {
+                fnStr = value.toString();
+            } catch (toStringErr) {
+                console.warn('CodeYam: Function.toString() threw error:', toStringErr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
+            // Defensive check: ensure fnStr is actually a string
+            if (typeof fnStr !== 'string') {
+                console.warn('CodeYam: Function.toString() returned non-string:', typeof fnStr, fnStr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
             // Check if it's an arrow function
             if (fnStr.includes('=>')) {
+                const arrowIndex = fnStr.indexOf('=>');
+                // Extra safety: verify indexOf returned a valid index
+                if (arrowIndex === -1) {
+                    console.warn('CodeYam: Arrow function detection inconsistency - includes found => but indexOf returned -1. fnStr:', fnStr);
+                    return {
+                        __type: TYPE_MARKERS.FUNCTION,
+                        value: fnStr,
+                        name: value.name
+                    };
+                }
                 return {
                     __type: TYPE_MARKERS.ARROW_FUNCTION,
-                    params: fnStr.substring(0, fnStr.indexOf('=>')).trim(),
-                    body: fnStr.substring(fnStr.indexOf('=>') + 2).trim()
+                    params: fnStr.substring(0, arrowIndex).trim(),
+                    body: fnStr.substring(arrowIndex + 2).trim()
                 };
             }
             return {

package/analyzer-template/project/writeScenario.ts

@@ -1,6 +1,6 @@
 import { Analysis, ProjectFramework, Scenario } from '~codeyam/types';
 import { CODEYAM_MOCKS_DIRNAME, pushAnalysisError } from '~codeyam/utils';
-import { loadFile, upsertAnalysesWithScenarios } from '~codeyam/supabase';
+import { loadFile, upsertAnalysesWithScenarios } from '~codeyam/database';
 import writeScenarioFiles from './writeScenarioFiles';
 import { ImmutableAnalysisContext, ProjectAnalyzer } from '~codeyam/analyze';
 import getAppPath from './getAppPath';