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

package/analyzer-template/packages/utils/src/lib/startCommand/index.ts

@@ -0,0 +1,10 @@
+export {
+  default as buildStartCommand,
+  type BuildStartCommandOptions,
+} from './buildStartCommand';
+
+export {
+  default as getWebappInfo,
+  type GetWebappInfoOptions,
+  type WebappInfo,
+} from './getWebappInfo';

package/analyzer-template/playwright/capture.ts

@@ -6,7 +6,7 @@ import {
   loadScenario,
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { default as checkURL, URLStatus } from './checkURL';
 import { Analysis, AnalysisStatus, Scenario } from '~codeyam/types';
 import getCodeYamInfo, { CodeYamInfo } from './getCodeYamInfo';
@@ -64,6 +64,46 @@ async function readControllerPortFromLog(
   return null;
 }
 
+/**
+ * Extract route params from scenario data for URL generation.
+ * Handles array values (for catch-all routes) by joining them.
+ *
+ * Scenario data can be stored in two locations:
+ * - scenario.data.argumentsData (primary)
+ * - scenario.metadata.data.argumentsData (fallback)
+ */
+function extractRouteParamsFromScenario(
+  scenario: Scenario,
+): Record<string, string | string[]> | undefined {
+  // Check both possible locations for argumentsData
+  const argumentsData =
+    scenario.data?.argumentsData ??
+    (scenario.metadata?.data as { argumentsData?: unknown[] } | undefined)
+      ?.argumentsData;
+
+  if (!Array.isArray(argumentsData) || argumentsData.length === 0) {
+    return undefined;
+  }
+
+  const params = (argumentsData[0] as Record<string, unknown>)?.params;
+  if (!params || typeof params !== 'object') {
+    return undefined;
+  }
+
+  const result: Record<string, string | string[]> = {};
+  for (const [key, value] of Object.entries(
+    params as Record<string, unknown>,
+  )) {
+    if (Array.isArray(value)) {
+      result[key] = value.map(String);
+    } else if (value !== null && value !== undefined) {
+      result[key] = String(value);
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 // Set process title for Activity Monitor visibility
 if (process.env.CODEYAM_PROCESS_NAME) {
   process.title = process.env.CODEYAM_PROCESS_NAME;
@@ -450,12 +490,15 @@ export default async function capture({
         let selector;
         if (isFrameworkRoute(file, analysis.entity, framework)) {
           awsLog('CodeYam: Route file', file.name);
+          // Extract route params from scenario mock data for URL generation
+          const routeParams = extractRouteParamsFromScenario(scenario);
           relativePath = frameworkRouteFileNameToRoute(
             projectSlug,
             file,
             analysis,
             framework,
             scenario.name,
+            routeParams,
           );
         } else {
           selector = '#component';
@@ -799,36 +842,12 @@ export default async function capture({
 
             // Check if all scenarios are now complete
             // dbScenarios comes from the scenarios table and gives us the accurate expected count
-            const expectedScenarioCount = dbScenarios.length;
-            awsLog('CodeYam DEBUG: Checking if all scenarios complete', {
-              analysisId: inAnalysis.id,
-              expectedScenarioCount,
-              actualStatusCount: freshStatus.scenarios.length,
-              dbScenarioNames: dbScenarios.map((s) => s.name),
-              statusScenarioNames: freshStatus.scenarios.map((s) => s.name),
-            });
-
-            const allScenariosAvailable =
-              freshStatus.scenarios.length >= expectedScenarioCount;
-            awsLog('CodeYam DEBUG: Scenario completion check', {
-              analysisId: inAnalysis.id,
-              expectedScenarioCount,
-              actualScenarioCount: freshStatus.scenarios.length,
-              allScenariosAvailable,
-              allHaveFinishedAt: freshStatus.scenarios.every(
-                (s) => !!s.finishedAt,
-              ),
-            });
             if (
-              allScenariosAvailable &&
+              freshStatus.scenarios.length >= dbScenarios.length &&
               freshStatus.scenarios.every((s) => !!s.finishedAt)
             ) {
               freshStatus.finishedAt = new Date().toISOString();
               freshStatus.readyToBeCaptured = false;
-              awsLog('CodeYam DEBUG: All scenarios complete result', {
-                analysisId: inAnalysis.id,
-                finishedAt: freshStatus.finishedAt,
-              });
             }
           },
         );
@@ -837,21 +856,6 @@ export default async function capture({
           1,
           `Capture process complete for ${analysis.entityName}: ${scenarioName}`,
         );
-        awsLog(
-          'CodeYam CAPTURE DEBUG: Capture Complete - about to call taskComplete',
-          {
-            fileId: file?.id,
-            analysisId: analysis?.id,
-            filePath: file?.path,
-            entityName:
-              analysis?.entity?.metadata?.exportAlias ?? analysis?.entityName,
-            scenarioName: scenario?.name,
-            scenarioId: scenario?.id,
-            entityType: analysis?.entity?.entityType,
-            isDefaultScenario: scenario.name === DEFAULT_SCENARIO_NAME,
-            controllerUrl,
-          },
-        );
 
         await taskComplete(controllerUrl, scenario.id);
 
@@ -861,17 +865,6 @@ export default async function capture({
           includeScenarios: true,
         });
 
-        awsLog('CodeYam DEBUG: Checking if all scenarios complete', {
-          analysisId: analysis.id,
-          scenarioCount: freshAnalysis.scenarios.length,
-          scenarios: freshAnalysis.scenarios.map((s) => s.name),
-          statusScenarios: freshAnalysis.status?.scenarios?.map((ss) => ({
-            name: ss.name,
-            hasFinishedAt: !!ss.finishedAt,
-            hasError: !!ss.error,
-          })),
-        });
-
         const allScenariosComplete = freshAnalysis.scenarios.every((s) => {
           const scenarioStatus = freshAnalysis.status?.scenarios?.find(
             (ss) => ss.name === s.name,
@@ -879,21 +872,7 @@ export default async function capture({
           // A scenario is only complete if it has finishedAt
           // An error alone is not enough - that might just be the protective error
           // set before the server starts
-          const isComplete = !!scenarioStatus?.finishedAt;
-
-          awsLog('CodeYam DEBUG: Scenario completion check', {
-            scenarioName: s.name,
-            hasStatus: !!scenarioStatus,
-            hasFinishedAt: !!scenarioStatus?.finishedAt,
-            hasError: !!scenarioStatus?.error,
-            isComplete,
-          });
-
-          return isComplete;
-        });
-
-        awsLog('CodeYam DEBUG: All scenarios complete result', {
-          allScenariosComplete,
+          return !!scenarioStatus?.finishedAt;
         });
 
         if (allScenariosComplete) {

package/analyzer-template/playwright/captureFromUrl.ts

@@ -8,7 +8,7 @@ import {
   loadProject,
   loadScenario,
   upsertScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { loadEnv } from '~codeyam/utils/server';
@@ -33,7 +33,13 @@ async function main() {
   }
 
   const config: CaptureArgs = JSON.parse(args[0]);
-  const { url, scenarioId, projectId, projectRoot, viewportWidth = 1440 } = config;
+  const {
+    url,
+    scenarioId,
+    projectId,
+    projectRoot,
+    viewportWidth = 1440,
+  } = config;
 
   // KEY DEBUG INFO: What URL are we capturing?
   console.log(`[Capture] Received URL: ${url}`);
@@ -42,35 +48,49 @@ async function main() {
   // Load the scenario from database
   const scenario = await loadScenario({ id: scenarioId, projectId });
   if (!scenario) {
-    console.error(`[Capture] ERROR: Scenario ${scenarioId} not found in database`);
+    console.error(
+      `[Capture] ERROR: Scenario ${scenarioId} not found in database`,
+    );
     process.exit(1);
   }
 
   // KEY DEBUG INFO: What data does this scenario have?
-  console.log(`[Capture] Loaded scenario from DB: "${scenario.name}" (id: ${scenario.id})`);
+  console.log(
+    `[Capture] Loaded scenario from DB: "${scenario.name}" (id: ${scenario.id})`,
+  );
   console.log(`[Capture] Scenario analysisId: ${scenario.analysisId}`);
 
   const argData = scenario.metadata?.data?.argumentsData;
   if (Array.isArray(argData) && argData.length > 0) {
-    console.log(`[Capture] Scenario data preview: ${JSON.stringify(argData[0]).substring(0, 200)}...`);
+    console.log(
+      `[Capture] Scenario data preview: ${JSON.stringify(argData[0]).substring(0, 200)}...`,
+    );
   } else {
     console.log(`[Capture] Scenario has no argumentsData`);
   }
 
   // Load analysis to get fileId (required for correct screenshot path convention)
   // Also load scenarios so we can regenerate MockData.tsx
-  const analysis = await loadAnalysis({ id: scenario.analysisId, includeFile: true, includeScenarios: true });
+  const analysis = await loadAnalysis({
+    id: scenario.analysisId,
+    includeFile: true,
+    includeScenarios: true,
+  });
   if (!analysis) {
     console.error(`[Capture] ERROR: Analysis ${scenario.analysisId} not found`);
     process.exit(1);
   }
   if (!analysis.file?.id) {
-    console.error(`[Capture] ERROR: Analysis ${scenario.analysisId} has no associated file`);
+    console.error(
+      `[Capture] ERROR: Analysis ${scenario.analysisId} has no associated file`,
+    );
     process.exit(1);
   }
   const fileId = analysis.file.id;
   console.log(`[Capture] Analysis fileId: ${fileId}`);
-  console.log(`[Capture] Analysis scenarios count: ${analysis.scenarios?.length || 0}`);
+  console.log(
+    `[Capture] Analysis scenarios count: ${analysis.scenarios?.length || 0}`,
+  );
 
   // Load project to get slug for screenshot path
   const project = await loadProject({ id: projectId });
@@ -82,7 +102,9 @@ async function main() {
 
   // Regenerate MockData.tsx to ensure dev server has the latest scenario data
   // This is critical for recapture to show updated data
-  console.log(`[Capture] Regenerating MockData.tsx for scenario: ${scenario.name}`);
+  console.log(
+    `[Capture] Regenerating MockData.tsx for scenario: ${scenario.name}`,
+  );
 
   try {
     // Load config to find which webapp this analysis belongs to
@@ -94,7 +116,9 @@ async function main() {
     console.log(`[Capture] Analysis file path: ${filePath}`);
 
     // Find which webapp this file belongs to
-    const webapp = projectConfig.webapps?.find((w: { path: string }) => filePath.startsWith(w.path));
+    const webapp = projectConfig.webapps?.find((w: { path: string }) =>
+      filePath.startsWith(w.path),
+    );
 
     if (webapp) {
       console.log(`[Capture] Found webapp: ${webapp.path}`);
@@ -105,7 +129,7 @@ async function main() {
         localDevProjectPath,
         webapp.path,
         webapp.appDirectory || 'app',
-        '__codeyamMocks__'
+        '__codeyamMocks__',
       );
 
       console.log(`[Capture] MockData.tsx directory: ${mocksDir}`);
@@ -117,7 +141,7 @@ async function main() {
       };
 
       // If the current scenario isn't in the scenarios array, add it
-      if (!analysisWithScenarios.scenarios.find(s => s.id === scenario.id)) {
+      if (!analysisWithScenarios.scenarios.find((s) => s.id === scenario.id)) {
         analysisWithScenarios.scenarios.push(scenario);
       }
 
@@ -126,19 +150,26 @@ async function main() {
 
       // Give the dev server time to hot-reload the updated MockData.tsx
       console.log(`[Capture] Waiting for dev server to reload...`);
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await new Promise((resolve) => setTimeout(resolve, 2000));
       console.log(`[Capture] Proceeding with screenshot capture`);
     } else {
-      console.log(`[Capture] WARNING: Could not find webapp for file ${filePath}, skipping MockData.tsx regeneration`);
+      console.log(
+        `[Capture] WARNING: Could not find webapp for file ${filePath}, skipping MockData.tsx regeneration`,
+      );
     }
   } catch (mockError) {
-    console.error(`[Capture] WARNING: Failed to regenerate MockData.tsx:`, mockError);
+    console.error(
+      `[Capture] WARNING: Failed to regenerate MockData.tsx:`,
+      mockError,
+    );
     // Continue with screenshot capture even if MockData regeneration fails
   }
 
   // Screenshot path convention: {slug}/{fileId}/{analysisId}/{scenarioName}.png
   // This matches the original capture system in capture.ts
-  const sanitizedName = scenario.name.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_-]/g, '');
+  const sanitizedName = scenario.name
+    .replace(/\s+/g, '_')
+    .replace(/[^a-zA-Z0-9_-]/g, '');
   const screenshotFileName = `${sanitizedName}.png`;
   const capturesDir = path.join(
     projectRoot,
@@ -147,7 +178,7 @@ async function main() {
     'screenshots',
     projectSlug,
     fileId,
-    scenario.analysisId
+    scenario.analysisId,
   );
   const screenshotPath = path.join(capturesDir, screenshotFileName);
 

package/analyzer-template/playwright/captureStatic.ts

@@ -4,7 +4,7 @@ import {
   updateCommitMetadata,
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { uploadAssetDirectory } from './uploadAssets';
 import invalidateCloudFrontPath from './invalidateCloudFrontPath';
 import { awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';

package/analyzer-template/playwright/takeElementScreenshot.ts

@@ -390,10 +390,19 @@ export default async function takeElementScreenshot({
       `[${screenshotId}] Step 7 complete: Screenshot taken=${shotTaken}, elapsed: ${Date.now() - startTime}ms`,
     );
 
+    // Track first screenshot in case fullPage fallback is also uniform
+    let firstScreenshotWasUniform = false;
+    let firstScreenshotBackup: Buffer | null = null;
+
     if (shotTaken) {
       const isUniform = await isImageUniform(screenshotPath).catch(() => false);
       if (isUniform) {
         awsLog(`[${screenshotId}] Screenshot is uniform, trying full screen`);
+        // Backup the first screenshot - it's smaller than fullPage fallback
+        firstScreenshotWasUniform = true;
+        firstScreenshotBackup = await fs
+          .readFile(screenshotPath)
+          .catch((): null => null);
         shotTaken = false; // reset shotTaken to false, we will set it to true later if successful
       }
     }
@@ -415,6 +424,19 @@ export default async function takeElementScreenshot({
       awsLog(
         `[${screenshotId}] Step 7b complete: Full page screenshot taken=${shotTaken}, elapsed: ${Date.now() - startTime}ms`,
       );
+
+      // If fullPage is also uniform, restore the smaller first screenshot
+      if (shotTaken && firstScreenshotWasUniform && firstScreenshotBackup) {
+        const fullPageUniform = await isImageUniform(screenshotPath).catch(
+          () => false,
+        );
+        if (fullPageUniform) {
+          awsLog(
+            `[${screenshotId}] Full page also uniform, restoring smaller first screenshot`,
+          );
+          await fs.writeFile(screenshotPath, firstScreenshotBackup);
+        }
+      }
     }
 
     if (shotTaken)

package/analyzer-template/playwright/takeScreenshot.ts

@@ -9,7 +9,7 @@ import { uploadAssetFile } from './uploadAssets';
 import {
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import invalidateCloudFrontPath from './invalidateCloudFrontPath';
 import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
 import { PlaywrightStep } from './executeInstuctions';
@@ -108,6 +108,7 @@ export default async function takeScreenshot({
 
     let isUniform = false;
     let screenshotTaken = false;
+    let firstUniformScreenshot: Buffer | null = null;
 
     for (const urlSuffix of dimensionRetries) {
       const result = await takeElementScreenshot({
@@ -118,6 +119,15 @@ export default async function takeScreenshot({
       isUniform = result.isUniform;
       screenshotTaken = result.screenshotTaken;
 
+      // Backup the first screenshot in case all retries are uniform
+      // (the first one without dimension overrides is typically smallest)
+      if (urlSuffix === '' && screenshotTaken && isUniform) {
+        const fs = await import('fs/promises');
+        firstUniformScreenshot = await fs
+          .readFile(screenshotPath)
+          .catch((): null => null);
+      }
+
       // Stop retrying if screenshot is good or if it wasn't taken (different problem)
       if (!isUniform || !screenshotTaken) {
         break;
@@ -133,6 +143,18 @@ export default async function takeScreenshot({
       });
     }
 
+    // If all retries produced uniform screenshots, restore the first one
+    // (it's the smallest since it has no dimension overrides)
+    if (isUniform && screenshotTaken && firstUniformScreenshot) {
+      awsLog(`CodeYam: All retries uniform, restoring first screenshot`, {
+        filePath: analysis.filePath,
+        entityName: analysis.entityName,
+        scenarioName: scenario.name,
+      });
+      const fs = await import('fs/promises');
+      await fs.writeFile(screenshotPath, firstUniformScreenshot);
+    }
+
     if (isUniform) {
       awsLog(`CodeYam: Screenshot is uniform`, {
         filePath: analysis.filePath,
@@ -188,12 +210,16 @@ export default async function takeScreenshot({
 
         if (!screenshotTaken) {
           freshScenario.metadata.noScreenshotSaved = true;
-          statusScenario.error = 'Screenshot not taken properly';
+          if (!statusScenario.error) {
+            statusScenario.error = 'Screenshot not taken properly';
+          }
         }
 
         if (isUniform) {
           freshScenario.metadata.isUniformScreenshot = true;
-          statusScenario.error = 'Screenshot is uniform';
+          if (!statusScenario.error) {
+            statusScenario.error = 'Screenshot is uniform';
+          }
         }
       },
     );

package/analyzer-template/playwright/updateBackgroundJob.ts

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

package/analyzer-template/project/LazyFileStore.ts

@@ -5,7 +5,7 @@ import {
   loadEntities,
   saveFiles,
   generateSha,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 
 export interface LazyFileStoreOptions {
   project: Project;

package/analyzer-template/project/TESTING.md

@@ -0,0 +1,83 @@
+# Testing writeScenarioComponents
+
+This document describes how to test changes to `writeScenarioComponents.ts`.
+
+## 1. Run the specific test
+
+```bash
+npx jest background/src/lib/virtualized/project/__tests__/writeScenarioComponents.test.ts -t "test name here" --no-coverage
+```
+
+## 2. Run all tests in the file
+
+```bash
+npx jest background/src/lib/virtualized/project/__tests__/writeScenarioComponents.test.ts --no-coverage -w 2
+```
+
+## 3. Rebuild and reinstall the CLI
+
+The globally installed CLI must be reinstalled to pick up changes:
+
+```bash
+# Remove the globally installed CLI and rebuild
+rm -rf /Users/jaredcosulich/.nvm/versions/node/v20.16.0/lib/node_modules/@codeyam/codeyam-cli && pnpm cli
+```
+
+## 4. Restart the server in the client project
+
+After rebuilding the CLI, restart the codeyam server in the client project:
+
+```bash
+cd /Users/jaredcosulich/workspace/codeyam/formbricks && codeyam stop & codeyam
+```
+
+## 5. Force analyzer update and run debug
+
+The analyzer is cached in `/tmp/codeyam/local-dev/{project-slug}/codeyam/analyzer`.
+To force it to use the new code:
+
+```bash
+# Remove cached analyzer
+rm -rf /tmp/codeyam/local-dev/formbricks-formbricks/codeyam/analyzer
+
+# Run debug (from the project directory)
+cd /Users/jaredcosulich/workspace/codeyam/formbricks && codeyam debug <analysis-id>
+```
+
+## 6. Verify the fix
+
+```bash
+# Check version in logs (should match version in writeScenarioComponents.ts)
+grep "CodeYam \[v" /tmp/codeyam/local-dev/formbricks-formbricks/codeyam/log.txt | tail -3
+
+# Check generated files
+head -30 /tmp/codeyam/local-dev/formbricks-formbricks/project/path/to/generated/file.tsx
+
+# List data scenario files
+ls -la /tmp/codeyam/local-dev/formbricks-formbricks/project/apps/web/lib/*_data_Default_Scenario*
+```
+
+## 7. Start dev server and test in browser
+
+```bash
+cd /tmp/codeyam/local-dev/formbricks-formbricks/project/apps/web && pnpm next dev --turbopack -p 3112
+```
+
+Test the actual simulation page (not just codeyam-sample):
+
+```bash
+# Format: /static/{project-slug}/{analysis-id}/{entity-name}/{scenario-name}/default
+curl http://localhost:3112/static/formbricks-formbricks/7925cfe4-7789-470d-bddc-2a85e48ef356/SurveysPage/Default_Scenario/default
+```
+
+Visit in browser: http://localhost:3112/static/formbricks-formbricks/7925cfe4-7789-470d-bddc-2a85e48ef356/SurveysPage/Default_Scenario/default
+
+## Version Tracking
+
+The version is defined in `writeScenarioComponents.ts`:
+
+```typescript
+const WRITE_SCENARIO_COMPONENTS_VERSION = '2.5.13-strip-use-server-directive';
+```
+
+Increment this when making changes to help track which version is running.

package/analyzer-template/project/analyzeBaselineCommit.ts

@@ -6,7 +6,7 @@ import {
   upsertAnalysisBranches,
   updateCommitMetadata,
   updateProjectMetadata,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { awsLog } from '~codeyam/utils';
 import { LazyFileStore } from './LazyFileStore';
 

package/analyzer-template/project/analyzeBranchCommit.ts

@@ -12,7 +12,7 @@ import {
   loadFile,
   updateCommitMetadata,
   updateProjectMetadata,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import checkApprovedPath from './checkApprovedPath';
 import { LazyFileStore } from './LazyFileStore';
 

package/analyzer-template/project/analyzeFileEntities.ts

@@ -12,7 +12,7 @@ import {
   loadEntity,
   updateCommitMetadata,
   upsertCommits,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { analyzeFileMocks } from './mocks/analyzeFileMock';
 import { LazyFileStore } from './LazyFileStore';
 

package/analyzer-template/project/analyzeRegularCommit.ts

@@ -16,7 +16,7 @@ import {
   updateCommitMetadata,
   upsertAnalysesWithScenarios,
   upsertAnalysisBranches,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
 import { LazyFileStore } from './LazyFileStore';
 

package/analyzer-template/project/captureLibraryFunctionDirect.ts

@@ -4,7 +4,7 @@ import {
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
   loadAnalysis,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import executeLibraryFunctionDirect from './executeLibraryFunctionDirect';
 
 /**