@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

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

@@ -0,0 +1,97 @@
+import { Analysis } from '~codeyam/types';
+import dbToAnalysis from './dbToAnalysis';
+import { getDatabase, getJsonHelper } from './kysely/db';
+import { sql, ExpressionBuilder } from 'kysely';
+import { aliasedTableColumns } from './kysely/aggregationHelpers';
+import { EntitiesTableColumns } from './kysely/tables/entitiesTable';
+import { ScenariosTableColumns } from './kysely/tables/scenariosTable';
+import { DbAnalysis } from './kysely/tableRelations';
+
+export interface LoadReadyToBeCapturedAnalysesArgs {
+  projectId?: string;
+  ids?: string[];
+  branchCommitSha?: string;
+}
+
+export default async function loadReadyToBeCapturedAnalyses(
+  params: LoadReadyToBeCapturedAnalysesArgs,
+): Promise<Analysis[]> {
+  const { projectId, branchCommitSha, ids } = params;
+
+  const db = getDatabase();
+  const { jsonObjectFrom, jsonArrayFrom } = getJsonHelper();
+
+  let query = db
+    .selectFrom('analyses')
+    .innerJoin('entities', 'entities.sha', 'analyses.entity_sha')
+    .selectAll('analyses')
+    .select((eb: ExpressionBuilder<any, any>) => [
+      jsonObjectFrom(
+        eb
+          .selectFrom('entities')
+          .select(aliasedTableColumns('entities', EntitiesTableColumns))
+          .whereRef('entities.sha', '=', 'analyses.entity_sha')
+          .limit(1),
+      ).as('entity'),
+      jsonArrayFrom(
+        eb
+          .selectFrom('scenarios')
+          .select(aliasedTableColumns('scenarios', ScenariosTableColumns))
+          .whereRef('scenarios.analysis_id', '=', 'analyses.id'),
+      ).as('scenarios'),
+    ])
+    .where(
+      // Use ->> to extract as text for proper comparison (-> returns JSONB which doesn't compare to string)
+      sql<string>` ${sql.ref('analyses.status')} ->> 'readyToBeCaptured'`,
+      '=',
+      'true',
+    )
+    // Exclude entities that are not exported - they cannot be captured because they can't be imported
+    .where(
+      sql<boolean>`(${sql.ref('entities.metadata')} ->> 'notExported') IS NULL OR (${sql.ref('entities.metadata')} ->> 'notExported') != 'true'`,
+    );
+
+  if (projectId) {
+    query = query.where('analyses.project_id', '=', projectId);
+  }
+
+  // Only filter by branchCommitSha if specific IDs are NOT provided
+  // When specific analysis IDs are requested (e.g., debug/recapture), we want those exact analyses
+  // regardless of their branch_commit_sha (which may be NULL in CLI scenarios)
+  if (branchCommitSha && (!ids || ids.length === 0)) {
+    query = query.where('analyses.branch_commit_sha', '=', branchCommitSha);
+  }
+
+  if (ids && ids.length > 0) {
+    query = query.where('analyses.id', 'in', ids);
+  }
+
+  const results = await query.execute();
+
+  if (!results || results.length === 0) {
+    console.log('CodeYam: No analyses found for readyToBeCaptured', {
+      projectId,
+      branchCommitSha,
+      ids: ids?.length,
+    });
+    return [];
+  }
+
+  const analyses = results as DbAnalysis[];
+  const mappedAnalyses = analyses.map(dbToAnalysis);
+
+  // Log entity export status for debugging notExported filtering
+  console.log(
+    'CodeYam: loadReadyToBeCapturedAnalyses results (notExported entities should be filtered)',
+    {
+      count: mappedAnalyses.length,
+      entities: mappedAnalyses.map((a) => ({
+        name: a.entityName,
+        filePath: a.filePath,
+        notExported: a.entity?.metadata?.notExported ?? false,
+      })),
+    },
+  );
+
+  return mappedAnalyses;
+}

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

@@ -0,0 +1,23 @@
+import { getDatabase } from './kysely/db';
+import { DbStatement } from '~codeyam/database';
+
+export default async function loadStatement(
+  sha: string,
+): Promise<Pick<DbStatement, 'sha' | 'results'> | null> {
+  try {
+    const result = await getDatabase()
+      .selectFrom('statements')
+      .select(['sha', 'results'])
+      .where('sha', '=', sha)
+      .executeTakeFirst();
+    // for unknown reasons, SQLite parses the JSON in 'results' even though
+    // the field is defined as text. We need to stringify it back.
+    if (result && result.results && typeof result.results !== 'string') {
+      result.results = JSON.stringify(result.results);
+    }
+    return result ?? null;
+  } catch (error) {
+    console.log('Error loading statement', error);
+    return null;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { Entity } from '~codeyam/types';
+import { getDatabase } from './kysely/db';
+import { EntityStatementsTable } from './kysely/tables/entityStatementsTable';
+import { type Insertable } from 'kysely';
+
+export default async function saveEntityStatements(
+  entity: Entity,
+  statementShas: string[],
+) {
+  if (statementShas.length === 0) return;
+
+  const dbEntityStatements: Insertable<EntityStatementsTable> =
+    statementShas.map((statementSha) => ({
+      project_id: entity.projectId,
+      entity_sha: entity.sha,
+      statement_sha: statementSha,
+    }));
+
+  try {
+    await getDatabase()
+      .insertInto('entity_statements')
+      .values(dbEntityStatements)
+      .executeTakeFirst();
+  } catch (error) {
+    console.log('Error saving entity statements', error);
+  }
+}

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

@@ -0,0 +1,35 @@
+import { Scenario } from '~codeyam/types';
+import { type Insertable } from 'kysely';
+import { ScenariosTable } from './kysely/tables/scenariosTable';
+import { randomUUID } from 'crypto';
+
+export default function scenarioToDb(
+  scenario: Scenario,
+): Insertable<ScenariosTable> {
+  const {
+    id,
+    projectId,
+    analysisId,
+    previousVersionId,
+    analysis,
+    metadata,
+    data,
+    ...remaining
+  } = scenario;
+
+  delete remaining.userScenarios;
+  delete remaining.comments;
+
+  if ('created_at' in remaining) {
+    delete remaining.created_at;
+  }
+
+  return {
+    ...remaining,
+    id: id ?? randomUUID(),
+    metadata: metadata ? JSON.stringify(metadata) : null,
+    project_id: projectId,
+    analysis_id: analysisId,
+    previous_version_id: previousVersionId,
+  };
+}

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/src/lib/componentScenarioPage/componentScenarioPageNext.ts

@@ -39,7 +39,6 @@ export default function componentScenarioPageNext({
   type ReactNode,
   type ChangeEvent
 } from 'react';
-import Head from 'next/head';
 ${analysis.scenarios?.length > 0 && `import { scenarios } from "${relativeMocksDir}/MockData_${safeFileName(scenario.name)}";`}
 ${getComponentImportStatement({
   file,
@@ -58,17 +57,7 @@ ${getComponentImportStatement({
 // Inject image interception code at module level to run before any rendering
 ${getImageReplacementCode()}
 
-
-const NextHead = () => {
-  return (
-    <Head>
-      <title>${fileName}: ${escapeQuotes(scenario.name)} CodeYam Demo v${VERSION}</title>
-      <meta name="description" content="This is a demo of the ${fileName} component" />
-    </Head>
-  )
-};
-
-function Scenario({ name, width, children }: { name: string, width: string, children: ReactNode }) {
+function Scenario({ name, width, height, children }: { name: string, width: string, height: string, children: ReactNode }) {
   
   useEffect(() => {
     if (typeof window === 'undefined') return;
@@ -89,14 +78,14 @@ function Scenario({ name, width, children }: { name: string, width: string, chil
       return Math.max(100, bodyHeight, htmlHeight, scrollHeight);
     }
 
-    const height = calculateHeight();
-    parent.postMessage({ type: 'codeyam-resize', name, height }, '*');
+    const calculatedHeight = calculateHeight();
+    parent.postMessage({ type: 'codeyam-resize', name, height: calculatedHeight }, '*');
 
     const eventListener = (event) => {
       if (event.data.name === name) {
         if (event.data.type === 'codeyam-respond') {
-          const height = calculateHeight();
-          parent.postMessage({ type: 'codeyam-resize', name, height }, '*');
+          const calculatedHeight = calculateHeight();
+          parent.postMessage({ type: 'codeyam-resize', name, height: calculatedHeight }, '*');
         }
       }
     };
@@ -108,9 +97,9 @@ function Scenario({ name, width, children }: { name: string, width: string, chil
   return (
     <div className='w-full flex items-center justify-center'>
       <div id='component' style={{
-        width: width,
-        minWidth: width,
-        maxWidth: width,
+        minWidth: width !== 'auto' ? \`min(\${width}, 100vw)\` : undefined,
+        height: height !== 'auto' ? height : undefined,
+        minHeight: height !== 'auto' ? height : undefined,
         display: 'block',
         padding: '6px'
       }}>
@@ -121,13 +110,31 @@ function Scenario({ name, width, children }: { name: string, width: string, chil
 }
 
 export default function Index() {
+  const [searchParams] = useState(() =>
+    typeof window !== 'undefined'
+      ? new URLSearchParams(window.location.search)
+      : new URLSearchParams()
+  );
+  const widthOverride = searchParams.get('width');
+  const heightOverride = searchParams.get('height') || 'auto';
+
+  useEffect(() => {
+    document.title = "${fileName}: ${escapeQuotes(scenario.name)} 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");
+  }, []);
+
   ${getIFrameMessageListenerCode({ scenarioName: scenario.name })}
   ${getNextJsErrorClosingCode()}
 
   return (
     <div className='flex flex-col justify-center items-center h-screen' data-version={version}>
-      <NextHead />
-      ${scenarioComponent(entity, analysis, scenario)}
+      ${scenarioComponent(entity, analysis, scenario, { useOverrides: true })}
     </div>
   );
 }`;

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

@@ -18,8 +18,6 @@ export default function componentScenarioPageRemix(
   mocksDir: string,
 ) {
   return `import { ReactNode, useEffect, useCallback, useState } from 'react';
-import type { MetaFunction } from "@remix-run/node";
-import { useSearchParams } from "@remix-run/react";
 ${analysis.scenarios?.length > 0 && `import { scenarios } from "${mocksDir}/MockData_${safeFileName(scenario.name)}";`}
 ${getComponentImportStatement({
   file,
@@ -38,13 +36,6 @@ ${getComponentImportStatement({
 // Inject image interception code at module level to run before any rendering
 ${getImageReplacementCode()}
 
-export const meta: MetaFunction = () => {
-  return [
-    { title: "${file.name}: ${escapeQuotes(scenario.name)} CodeYam Demo v${VERSION}" },
-    { name: "description", content: "This is a demo of the ${file.name} component under the scenario: ${escapeQuotes(scenario.description)}" },
-  ];
-};
-
 function Scenario({ name, width, height, children }: { name: string, width: string, height: string, children: ReactNode }) {
 
   useEffect(() => {
@@ -85,7 +76,7 @@ function Scenario({ name, width, height, children }: { name: string, width: stri
   return (
     <div className='w-full flex items-center justify-center'>
       <div id='component' style={{
-        minWidth: \`min(\${width}, 100vw)\`,
+        minWidth: width !== 'auto' ? \`min(\${width}, 100vw)\` : undefined,
         height: height !== 'auto' ? height : undefined,
         minHeight: height !== 'auto' ? height : undefined,
         display: 'block',
@@ -98,9 +89,25 @@ function Scenario({ name, width, height, children }: { name: string, width: stri
 }
 
 export default function Index() {
-  const [searchParams] = useSearchParams();
+  const [searchParams] = useState(() =>
+    typeof window !== 'undefined'
+      ? new URLSearchParams(window.location.search)
+      : new URLSearchParams()
+  );
   const widthOverride = searchParams.get('width');
   const heightOverride = searchParams.get('height') || 'auto';
+
+  useEffect(() => {
+    document.title = "${file.name}: ${escapeQuotes(scenario.name)} 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 ${file.name} component under the scenario: ${escapeQuotes(scenario.description)}");
+  }, []);
+
   ${getIFrameMessageListenerCode({ scenarioName: scenario.name })}
 
   return (

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

@@ -17,7 +17,9 @@ export default function deepMerge(
     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])) {
         merge[key] = [];
         for (let i = 0; i < changes[key].length; i++) {

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

@@ -18,6 +18,22 @@ export default function directExecutionScript(
   scenario: Scenario,
 ): string {
   const { name: entityName } = entity;
+
+  // notExported entities cannot be imported, so we can't generate an execution script
+  if (entity.metadata?.notExported) {
+    console.log(
+      'CodeYam Error: directExecutionScript called with notExported entity',
+      {
+        entityName,
+        filePath: file.path,
+        metadata: entity.metadata,
+      },
+    );
+    throw new Error(
+      `Cannot generate execution script for entity '${entityName}' - it is not exported from '${file.path}'`,
+    );
+  }
+
   const safeEntityName =
     entityName === 'default' ? 'defaultExport' : entityName;
 
@@ -46,8 +62,7 @@ export default function directExecutionScript(
 
   // Determine if it's a named or default export
   const isDefaultExport = entity.name === 'default';
-  const isNamedExport =
-    entity.metadata?.namedExport || entity.metadata?.notExported;
+  const isNamedExport = entity.metadata?.namedExport;
 
   let importStatement: string;
   if (isMethod) {

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

@@ -23,13 +23,18 @@ export default function getComponentScenarioPath(
     getRelativePath(currentPath, filePath).split('/').slice(0, -1).join('/'),
   );
 
+  // Check if the file is an index file (e.g., index.tsx, index.ts)
+  // This must match the logic in writeScenarioComponents.ts
+  const isIndexFile = file.name.startsWith('index.');
+  const indexPrefix = isIndexFile ? 'index_' : '';
+
   if (scenario) {
     // Include scenario name in path to allow multiple scenarios to coexist
     const importPath = isLibraryDemoPage
-      ? `${relativePath}/${entity.sha}_${safeFileName(entityName)}_${safeFileName(scenario.name)}`
-      : `${relativePath}/${entity.sha}_${safeFileName(entityName)}_${safeFileName(scenario.name)}`;
+      ? `${relativePath}/${entity.sha}_${indexPrefix}${safeFileName(entityName)}_${safeFileName(scenario.name)}`
+      : `${relativePath}/${entity.sha}_${indexPrefix}${safeFileName(entityName)}_${safeFileName(scenario.name)}`;
     return `${importPath}`;
   }
 
-  return `${relativePath}_${entity.sha}_${safeFileName(entityName)}`;
+  return `${relativePath}_${entity.sha}_${indexPrefix}${safeFileName(entityName)}`;
 }