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

package/analyzer-template/packages/database/src/lib/updateCommitMetadata.ts

@@ -0,0 +1,187 @@
+/*
+ * updates commit metadata by merging partial updates with existing data.
+ * uses database transactions to ensure atomic updates and handle concurrent modifications.
+ */
+import {
+  Commit,
+  CommitMetadata,
+  CommitRunStatus,
+  DeepReadonly,
+} from '~codeyam/types';
+import { getDatabase } from './kysely/db';
+import { awsLog } from '~codeyam/utils';
+import { deepMerge, DeepUpdate } from './jsonUpdateUtils';
+import dbToCommit from './dbToCommit';
+
+type UpdateCommitMetadataArgs = {
+  commitId?: string;
+  commitSha?: string;
+  metadataUpdate?: DeepUpdate<CommitMetadata>;
+  runStatusUpdate?: DeepUpdate<CommitRunStatus>;
+  archiveCurrentRun?: boolean;
+  updateCallback?: (
+    metadata: CommitMetadata,
+    commit: DeepReadonly<Commit>,
+  ) => void | Promise<void>;
+};
+
+export default async function updateCommitMetadata({
+  commitId,
+  commitSha,
+  metadataUpdate,
+  runStatusUpdate,
+  archiveCurrentRun,
+  updateCallback,
+}: UpdateCommitMetadataArgs): Promise<CommitMetadata | null> {
+  try {
+    return await getDatabase()
+      .transaction()
+      .execute(async (trx) => {
+        const commit = await trx
+          .selectFrom('commits')
+          .selectAll()
+          .$if(!!commitId, (qb: any) => qb.where('id', '=', commitId))
+          .$if(!!commitSha, (qb: any) => qb.where('sha', '=', commitSha))
+          .executeTakeFirst();
+
+        if (!commit) {
+          awsLog(
+            `CodeYam Error: updateCommitMetadata(): Commit ${commitId} not found`,
+          );
+          return null;
+        }
+
+        // Initialize metadata if it doesn't exist (metadata is already parsed from DB)
+        const currentMetadata: CommitMetadata = commit.metadata || {};
+
+        // if the convenience parameter for latest run was supplied, merge it in
+        if (runStatusUpdate) {
+          runStatusUpdate.lastUpdatedAt ??= new Date().toISOString();
+
+          if (runStatusUpdate.currentEntityShas !== undefined) {
+            console.log(
+              `[updateCommitMetadata] Updating currentRun.currentEntityShas`,
+            );
+            console.log(`[updateCommitMetadata] Commit SHA: ${commitSha}`);
+            console.log(
+              `[updateCommitMetadata] Previous entity SHAs:`,
+              currentMetadata.currentRun?.currentEntityShas,
+            );
+            console.log(
+              `[updateCommitMetadata] New entity SHAs:`,
+              runStatusUpdate.currentEntityShas,
+            );
+            console.log(
+              `[updateCommitMetadata] Archive flag:`,
+              archiveCurrentRun,
+            );
+          }
+
+          metadataUpdate = deepMerge(metadataUpdate ?? {}, {
+            currentRun: runStatusUpdate,
+          });
+        } else if (!metadataUpdate && !updateCallback) {
+          return currentMetadata; // nothing to update
+        }
+
+        // Deep merge the baseline status updates
+        const updatedMetadata: CommitMetadata = metadataUpdate
+          ? deepMerge(currentMetadata, metadataUpdate)
+          : currentMetadata;
+
+        // Archive current run if requested
+        if (archiveCurrentRun && updatedMetadata.currentRun) {
+          console.log(
+            `[updateCommitMetadata] ========================================`,
+          );
+          console.log(`[updateCommitMetadata] ARCHIVING CURRENT RUN`);
+          console.log(`[updateCommitMetadata] Commit SHA: ${commitSha}`);
+          console.log(
+            `[updateCommitMetadata] Current run entity SHAs:`,
+            updatedMetadata.currentRun.currentEntityShas,
+          );
+          console.log(
+            `[updateCommitMetadata] Current run PIDs: analyzer=${updatedMetadata.currentRun.analyzerPid}, capture=${updatedMetadata.currentRun.capturePid}`,
+          );
+          console.log(
+            `[updateCommitMetadata] Current run completed: analyses=${updatedMetadata.currentRun.analysesCompleted}, captures=${updatedMetadata.currentRun.capturesCompleted}`,
+          );
+          console.log(
+            `[updateCommitMetadata] Historical runs before archiving: ${updatedMetadata.historicalRuns?.length || 0}`,
+          );
+
+          const runToArchive: CommitRunStatus = {
+            ...updatedMetadata.currentRun,
+            archivedAt: new Date().toISOString(),
+          };
+
+          console.log(
+            `[updateCommitMetadata] Run to archive:`,
+            JSON.stringify(runToArchive, null, 2),
+          );
+
+          updatedMetadata.historicalRuns = [
+            ...(updatedMetadata.historicalRuns || []),
+            runToArchive,
+          ];
+
+          console.log(
+            `[updateCommitMetadata] Historical runs after archiving: ${updatedMetadata.historicalRuns.length}`,
+          );
+          console.log(
+            `[updateCommitMetadata] All historical runs:`,
+            JSON.stringify(
+              updatedMetadata.historicalRuns.map((r) => ({
+                entityShas: r.currentEntityShas,
+                archivedAt: r.archivedAt,
+                completed: {
+                  analyses: r.analysesCompleted,
+                  captures: r.capturesCompleted,
+                },
+              })),
+              null,
+              2,
+            ),
+          );
+          console.log(
+            `[updateCommitMetadata] ========================================`,
+          );
+        }
+
+        // Allow callback to perform complex atomic updates
+        if (updateCallback) {
+          await updateCallback(updatedMetadata, dbToCommit(commit));
+        }
+
+        try {
+          const result = await trx
+            .updateTable('commits')
+            .set({ metadata: JSON.stringify(updatedMetadata) })
+            .where('id', '=', commit.id)
+            .returningAll()
+            .executeTakeFirst();
+
+          if (!result) {
+            awsLog(
+              `CodeYam Error: updateCommitMetadata(): Failed to update commit ${commitId}`,
+            );
+            return currentMetadata;
+          }
+
+          return updatedMetadata;
+        } catch (error) {
+          awsLog(
+            `CodeYam Error: updateCommitMetadata(): Failed to update commit ${commitId}`,
+            error,
+          );
+          return currentMetadata;
+        }
+      });
+  } catch (error) {
+    awsLog(
+      `CodeYam Error: updateCommitMetadata(): Transaction failed for commit ${commitId}`,
+      error,
+    );
+    return null;
+  }
+}

package/analyzer-template/packages/database/src/lib/updateProjectMetadata.ts

@@ -0,0 +1,95 @@
+/*
+ * Updates project metadata by merging partial updates with existing data.
+ * Uses database transactions to ensure atomic updates and handle concurrent modifications.
+ */
+import { DeepReadonly, Project, ProjectMetadata } from '~codeyam/types';
+import { getDatabase } from './kysely/db';
+import { awsLog } from '~codeyam/utils';
+import { deepMerge } from './jsonUpdateUtils';
+import dbToProject from './dbToProject';
+
+type UpdateProjectMetadataArgs = {
+  projectId?: string;
+  projectSlug?: string;
+  metadataUpdate?: Project['metadata'];
+  updateCallback?: (
+    metadata: Project['metadata'],
+    project: DeepReadonly<Project>,
+  ) => void | Promise<void>;
+};
+
+export default async function updateProjectMetadata({
+  projectId,
+  projectSlug,
+  metadataUpdate,
+  updateCallback,
+}: UpdateProjectMetadataArgs): Promise<ProjectMetadata | null> {
+  if (!projectId && !projectSlug) {
+    throw new Error('Either projectId or projectSlug must be provided');
+  }
+  try {
+    return await getDatabase()
+      .transaction()
+      .execute(async (trx) => {
+        const project = await trx
+          .selectFrom('projects')
+          .selectAll()
+          .$if(!!projectId, (qb: any) => qb.where('id', '=', projectId))
+          .$if(!!projectSlug, (qb: any) => qb.where('slug', '=', projectSlug))
+          .executeTakeFirst();
+
+        if (!project) {
+          awsLog(
+            `CodeYam Error: updateProjectMetadata(): Project ${projectId} not found`,
+          );
+          return null;
+        }
+
+        // Initialize metadata if it doesn't exist (metadata is already parsed from DB)
+        const currentMetadata: ProjectMetadata = project.metadata || {};
+        if (!metadataUpdate && !updateCallback) {
+          return currentMetadata; // nothing to update
+        }
+
+        // Deep merge the baseline status updates
+        const updatedMetadata: ProjectMetadata = metadataUpdate
+          ? deepMerge(currentMetadata, metadataUpdate)
+          : currentMetadata;
+
+        // Allow callback to perform complex atomic updates
+        if (updateCallback) {
+          await updateCallback(updatedMetadata, dbToProject(project));
+        }
+
+        try {
+          const result = await trx
+            .updateTable('projects')
+            .set({ metadata: JSON.stringify(updatedMetadata) })
+            .where('id', '=', project.id)
+            .returningAll()
+            .executeTakeFirst();
+
+          if (!result) {
+            awsLog(
+              `CodeYam Error: updateProjectMetadata(): Failed to update project ${projectId}`,
+            );
+            return null;
+          }
+
+          return updatedMetadata;
+        } catch (error) {
+          awsLog(
+            `CodeYam Error: updateProjectMetadata(): Failed to update project ${projectId}`,
+            error,
+          );
+          return null;
+        }
+      });
+  } catch (error) {
+    awsLog(
+      `CodeYam Error: updateProjectMetadata(): Transaction failed for project ${projectId}`,
+      error,
+    );
+    return null;
+  }
+}

package/analyzer-template/packages/generate/index.ts

@@ -1,6 +1,8 @@
 export { default as getComponentImportStatements } from './src/lib/getComponentImportStatements';
 export { default as componentScenarioPageRemix } from './src/lib/componentScenarioPage/componentScenarioPageRemix';
 export { default as componentScenarioPageNext } from './src/lib/componentScenarioPage/componentScenarioPageNext';
+export { default as generateScenarioServerComponent } from './src/lib/componentScenarioPage/generateScenarioServerComponent';
+export { default as generateScenarioClientWrapper } from './src/lib/componentScenarioPage/generateScenarioClientWrapper';
 export { default as getComponentScenarioPath } from './src/lib/getComponentScenarioPath';
 export { default as libDemoComponent } from './src/lib/libDemoComponent';
 export { default as directExecutionScript } from './src/lib/directExecutionScript';
@@ -9,4 +11,5 @@ export { default as safeFolder } from './src/lib/safeFolder';
 export { default as deepMerge } from './src/lib/deepMerge';
 export { default as simpleRootRemix } from './src/lib/simpleRootRemix';
 export { default as mergeRootRemix } from './src/lib/mergeRootRemix';
+export { default as scenarioComponentForServer } from './src/lib/scenarioComponentForServer';
 export { PLACEHOLDER_IMAGE_SRC } from './src/lib/constants';

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/componentScenarioPageNext.ts

@@ -6,6 +6,7 @@ import escapeQuotes from '../escapeQuotes';
 import getIFrameMessageListenerCode from './getIFrameMessageListenerCode';
 import getImageReplacementCode from './getImageReplacementCode';
 import getNextJsErrorClosingCode from './getNextJsErrorClosingCode';
+import generateScenarioServerComponent from './generateScenarioServerComponent';
 
 const VERSION = '0.5.1';
 
@@ -28,6 +29,21 @@ export default function componentScenarioPageNext({
 }) {
   const fileName = file.name.split('.')[0];
 
+  // For async components (Server Components), generate a Server Component page
+  // that uses a separate client wrapper for interactive features
+  if (entity.metadata?.isAsync) {
+    return generateScenarioServerComponent({
+      file,
+      entity,
+      analysis,
+      currentPath,
+      appPath,
+      scenario,
+      relativeMocksDir,
+    });
+  }
+
+  // For non-async components, use the existing client component approach
   return `/* eslint-disable */
   "use client";
   import {
@@ -58,7 +74,7 @@ ${getComponentImportStatement({
 ${getImageReplacementCode()}
 
 function Scenario({ name, width, height, children }: { name: string, width: string, height: string, children: ReactNode }) {
-  
+
   useEffect(() => {
     if (typeof window === 'undefined') return;
 

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/generateScenarioClientWrapper.ts

@@ -0,0 +1,193 @@
+import type { Scenario } from '~codeyam/types';
+import { safeFileName } from '~codeyam/utils';
+import getImageReplacementCode from './getImageReplacementCode';
+import getNextJsErrorClosingCode from './getNextJsErrorClosingCode';
+
+/**
+ * Generates the ScenarioClientWrapper component code.
+ * This is a Client Component that handles all the interactive features
+ * (iframe messaging, console interception, error closing, etc.)
+ * while allowing the actual page to be a Server Component.
+ */
+export default function generateScenarioClientWrapper(
+  scenario: Scenario,
+): string {
+  const safeScenarioName = safeFileName(scenario.name);
+
+  return `"use client";
+/* eslint-disable */
+// ScenarioClientWrapper - Client Component for interactive features
+// This wraps Server Components to add client-side interactivity
+
+import {
+  useCallback,
+  useEffect,
+  useState,
+  type ReactNode,
+} from 'react';
+import { scenarios } from "./MockData_${safeScenarioName}";
+
+// Inject image interception code at module level
+${getImageReplacementCode()}
+
+interface ScenarioClientWrapperProps {
+  scenarioName: string;
+  fileName: string;
+  version: string;
+  children: ReactNode;
+}
+
+export function ScenarioClientWrapper({
+  scenarioName,
+  fileName,
+  version,
+  children,
+}: ScenarioClientWrapperProps) {
+  const [internalVersion, setInternalVersion] = useState(1);
+  const [searchParams] = useState(() =>
+    typeof window !== 'undefined'
+      ? new URLSearchParams(window.location.search)
+      : new URLSearchParams()
+  );
+  const widthOverride = searchParams.get('width');
+  const heightOverride = searchParams.get('height') || 'auto';
+
+  // Set page metadata
+  useEffect(() => {
+    document.title = \`\${fileName}: \${scenarioName} CodeYam Demo v\${version}\`;
+    let metaDesc = document.querySelector('meta[name="description"]');
+    if (!metaDesc) {
+      metaDesc = document.createElement('meta');
+      metaDesc.setAttribute('name', 'description');
+      document.head.appendChild(metaDesc);
+    }
+    metaDesc.setAttribute('content', \`This is a demo of the \${fileName} component\`);
+  }, [fileName, scenarioName, version]);
+
+  // Message posting helper
+  const respond = useCallback((message: any) => {
+    try {
+      window.parent.postMessage({
+        type: 'codeyam-update',
+        name: scenarioName,
+        message,
+      }, '*');
+    } catch (e) {
+      console.warn('Error posting message to parent', message, e);
+    }
+  }, [scenarioName]);
+
+  // Handle data override messages from parent
+  useEffect(() => {
+    const eventListener = (event: MessageEvent) => {
+      if (event.data.type === 'codeyam-override-data') {
+        const parsedData = JSON.parse(event.data.data);
+        console.log("Override data received");
+        respond("Set override data to " + JSON.stringify(parsedData, null, 2));
+        scenarios().updateData(scenarioName, parsedData);
+        setInternalVersion(prev => prev + 1);
+      }
+    };
+    window.addEventListener('message', eventListener);
+    return () => window.removeEventListener('message', eventListener);
+  }, [respond, scenarioName]);
+
+  // Console interception
+  useEffect(() => {
+    const oldConsoleLog = console.log;
+    console.log = function(...args: any[]) {
+      oldConsoleLog(...args);
+      try {
+        window.parent.postMessage({
+          type: 'codeyam-log',
+          name: scenarioName,
+          data: {
+            log: {
+              name: "console.log",
+              args
+            }
+          }
+        }, '*');
+      } catch (e) {
+        oldConsoleLog('Error posting message to parent', e);
+      }
+    };
+
+    const oldConsoleError = console.error;
+    console.error = function(...args: any[]) {
+      oldConsoleError(...args);
+      window.parent.postMessage({
+        type: 'codeyam-log',
+        name: scenarioName,
+        data: {
+          log: {
+            name: "console.error",
+            args
+          }
+        }
+      }, '*');
+    };
+
+    return () => {
+      console.log = oldConsoleLog;
+      console.error = oldConsoleError;
+    };
+  }, [scenarioName]);
+
+  // Next.js error closing
+  ${getNextJsErrorClosingCode()}
+
+  // Height calculation and resize messaging
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+
+    const calculateHeight = () => {
+      const bodyHeight = document.body.offsetHeight;
+      const htmlHeight = document.documentElement.offsetHeight;
+      const scrollHeight = Math.max(
+        document.body.scrollHeight,
+        document.documentElement.scrollHeight,
+        document.body.offsetHeight,
+        document.documentElement.offsetHeight,
+        document.body.clientHeight,
+        document.documentElement.clientHeight
+      );
+      return Math.max(100, bodyHeight, htmlHeight, scrollHeight);
+    };
+
+    const calculatedHeight = calculateHeight();
+    parent.postMessage({ type: 'codeyam-resize', name: scenarioName, height: calculatedHeight }, '*');
+
+    const eventListener = (event: MessageEvent) => {
+      if (event.data.name === scenarioName) {
+        if (event.data.type === 'codeyam-respond') {
+          const calculatedHeight = calculateHeight();
+          parent.postMessage({ type: 'codeyam-resize', name: scenarioName, height: calculatedHeight }, '*');
+        }
+      }
+    };
+
+    window.addEventListener('message', eventListener);
+    return () => window.removeEventListener('message', eventListener);
+  }, [scenarioName]);
+
+  const width = widthOverride || 'auto';
+
+  return (
+    <div className='flex flex-col justify-center items-center h-screen' data-version={internalVersion}>
+      <div className='w-full flex items-center justify-center'>
+        <div id='component' style={{
+          minWidth: width !== 'auto' ? \`min(\${width}, 100vw)\` : undefined,
+          height: heightOverride !== 'auto' ? heightOverride : undefined,
+          minHeight: heightOverride !== 'auto' ? heightOverride : undefined,
+          display: 'block',
+          padding: '6px'
+        }}>
+          {children}
+        </div>
+      </div>
+    </div>
+  );
+}
+`;
+}

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/generateScenarioServerComponent.ts

@@ -0,0 +1,73 @@
+import { Entity, Analysis, type File, type Scenario } from '~codeyam/types';
+import { safeFileName } from '~codeyam/utils';
+import getComponentImportStatement from '../getComponentImportStatement';
+import scenarioComponentForServer from '../scenarioComponentForServer';
+
+const VERSION = '0.5.1';
+
+/**
+ * Generates a Server Component page for async components (Server Components in Next.js).
+ *
+ * This is needed because:
+ * 1. Async components use await, which only works in Server Components
+ * 2. Client Components ("use client") don't support async/await in the component body
+ * 3. We use Next.js composition pattern: Server Component page renders the async component,
+ *    then wraps it in a Client Component (ScenarioClientWrapper) for interactive features
+ */
+export default function generateScenarioServerComponent({
+  file,
+  entity,
+  analysis,
+  currentPath,
+  appPath,
+  scenario,
+  relativeMocksDir,
+}: {
+  file: File;
+  entity: Entity;
+  analysis: Analysis;
+  currentPath: string;
+  appPath: string;
+  scenario: Scenario;
+  relativeMocksDir: string;
+}) {
+  const fileName = file.name.split('.')[0];
+  const safeScenarioName = safeFileName(scenario.name);
+
+  return `/* eslint-disable */
+// Server Component page for async component: ${entity.name}
+// This page does NOT have "use client" - it runs on the server
+import { ScenarioClientWrapper } from "${relativeMocksDir}/ScenarioClientWrapper";
+${analysis.scenarios?.length > 0 ? `import { scenarios } from "${relativeMocksDir}/MockData_${safeScenarioName}";` : ''}
+${getComponentImportStatement({
+  file,
+  entity,
+  analysis,
+  currentPath,
+  appPath,
+  scenario,
+  primary: true,
+  namedExport:
+    entity.name !== 'default' &&
+    (entity.metadata?.notExported || entity.metadata?.namedExport) &&
+    entity.entityType !== 'library',
+})}
+
+function getScenarioProps({ argumentIndex, propName }: { argumentIndex: number, propName?: string }) {
+  const data = scenarios().data();
+  const argument = data['arguments'][argumentIndex];
+  return propName ? argument[propName] : argument;
+}
+
+export default async function Index() {
+  return (
+    <ScenarioClientWrapper
+      scenarioName="${scenario.name}"
+      fileName="${fileName}"
+      version="${VERSION}"
+    >
+      ${scenarioComponentForServer(entity, analysis, scenario)}
+    </ScenarioClientWrapper>
+  );
+}`;
+}

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/getIFrameMessageListenerCode.ts

@@ -3,6 +3,11 @@ export default function getIFrameMessageListenerCode({
 }: {
   scenarioName: string;
 }): string {
+  // Escape backslashes first, then single quotes to produce valid JS string literals
+  const escapedScenarioName = scenarioName
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'");
+
   return `const [version, setVersion] = useState(1);
 
   function _getScenarioProps({ argumentIndex, propName }: { argumentIndex: number, propName?: string }) {
@@ -14,7 +19,7 @@ export default function getIFrameMessageListenerCode({
     try {
       window.parent.postMessage({ 
         type: 'codeyam-update', 
-        name: '${scenarioName}',
+        name: '${escapedScenarioName}',
         message,
       }, '*');
     } catch (e) {
@@ -28,7 +33,7 @@ export default function getIFrameMessageListenerCode({
         const parsedData = JSON.parse(event.data.data);
         console.log("Override data received");
         respond("Set override data to " + JSON.stringify(parsedData, null, 2));
-        scenarios().updateData('${scenarioName}', parsedData);
+        scenarios().updateData('${escapedScenarioName}', parsedData);
         setVersion(prev => prev + 1);
       }
     }
@@ -44,7 +49,7 @@ export default function getIFrameMessageListenerCode({
       try {
         window.parent.postMessage({
           type: 'codeyam-log',
-          name: '${scenarioName}',
+          name: '${escapedScenarioName}',
           data: {
             log: {
               name: "console.log",
@@ -62,7 +67,7 @@ export default function getIFrameMessageListenerCode({
       oldConsoleError(...args);
       window.parent.postMessage({
         type: 'codeyam-log',
-        name: '${scenarioName}',
+        name: '${escapedScenarioName}',
         data: {
           log: {
             name: "console.log",

package/analyzer-template/packages/generate/src/lib/deepMerge.ts

@@ -14,16 +14,43 @@ export default function deepMerge(
       seen.add(changes);
     }
 
+    // Handle arrays at the top level - this is critical for nested arrays (tuples)
+    // like [["path", { data }]] which should NOT be converted to objects
+    if (Array.isArray(changes)) {
+      const defaultArray = Array.isArray(defaultData) ? defaultData : [];
+      const result: any[] = [];
+      for (let i = 0; i < changes.length; i++) {
+        const item = changes[i];
+        if (item && typeof item === 'object' && !Array.isArray(item)) {
+          // Merge object items with corresponding default array item
+          result[i] = deepMerge(defaultArray[i], item, seen);
+        } else if (Array.isArray(item)) {
+          // Recursively handle nested arrays (tuples)
+          result[i] = deepMerge(defaultArray[i], item, seen);
+        } else {
+          result[i] = item;
+        }
+      }
+      return result;
+    }
+
     const merge = { ...defaultData };
     for (const key in changes) {
       if (changes[key] === null) {
-        delete merge[key];
+        // Preserve null values explicitly - components often check `value !== null`
+        // to distinguish between "not loaded" (undefined) and "explicitly null" (null)
+        merge[key] = null;
       } else if (Array.isArray(changes[key])) {
+        // Get the original default array BEFORE we replace it
+        const defaultArray = Array.isArray(defaultData[key])
+          ? defaultData[key]
+          : [];
         merge[key] = [];
         for (let i = 0; i < changes[key].length; i++) {
           const item = changes[key][i];
           if (typeof item === 'object' && item !== null) {
-            merge[key][i] = deepMerge(merge?.[key]?.[i], item, seen);
+            // Merge with corresponding item from default array by index position
+            merge[key][i] = deepMerge(defaultArray[i], item, seen);
           } else {
             merge[key][i] = item;
           }