@codeyam/codeyam-cli 0.1.0-staging.76566f9 → 0.1.0-staging.78c1cad

package/analyzer-template/packages/utils/dist/utils/src/lib/safeFileName.js.map

@@ -1 +1 @@
-{"version":3,"file":"safeFileName.js","sourceRoot":"","sources":["../../../../src/lib/safeFileName.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,IAAY;IAC/C,yEAAyE;IACzE,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAE9E,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,CAAC;IAEzB,6EAA6E;IAC7E,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAChE,CAAC"}
+{"version":3,"file":"safeFileName.js","sourceRoot":"","sources":["../../../../src/lib/safeFileName.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,SAAS,UAAU,CAAC,GAAW;IAC7B,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,IAAI,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IACD,6CAA6C;IAC7C,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACpD,CAAC;AAWD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,IAAY,EACZ,UAA+B,EAAE;IAEjC,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAE9B,yEAAyE;IACzE,2EAA2E;IAC3E,IAAI,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAE5E,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,CAAC;IAEzB,6EAA6E;IAC7E,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAElE,6EAA6E;IAC7E,IAAI,SAAS,IAAI,QAAQ,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;QAC7C,6DAA6D;QAC7D,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAE9B,sDAAsD;QACtD,MAAM,cAAc,GAAG,SAAS,GAAG,CAAC,CAAC;QACrC,MAAM,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QAExD,mEAAmE;QACnE,MAAM,cAAc,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEpD,QAAQ,GAAG,GAAG,cAAc,IAAI,IAAI,EAAE,CAAC;IACzC,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/analyzer-template/packages/utils/src/lib/fs/rsyncCopy.ts

@@ -1,4 +1,87 @@
-import { spawn } from 'child_process';
+import { execSync, spawn } from 'child_process';
+import { existsSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Try to use APFS copy-on-write clones on macOS for near-instant directory copies.
+ * Falls back to rsync on non-macOS or if the clone fails.
+ *
+ * Returns true if the clone succeeded (caller can skip rsync).
+ */
+function tryApfsClone({
+  sourcePath,
+  destinationPath,
+  excludes,
+  silent,
+}: {
+  sourcePath: string;
+  destinationPath: string;
+  excludes: string[];
+  silent: boolean;
+}): boolean {
+  if (process.platform !== 'darwin') return false;
+
+  // APFS clone requires the destination to not exist.
+  // If it exists and is empty, remove it so we can clone into it.
+  if (existsSync(destinationPath)) {
+    try {
+      const contents = readdirSync(destinationPath);
+      if (contents.length > 0) {
+        // Destination is non-empty — can't use clone, fall back to rsync
+        return false;
+      }
+      rmSync(destinationPath, { recursive: true });
+    } catch {
+      return false;
+    }
+  }
+
+  try {
+    // cp -c -R: APFS copy-on-write clone (faster than rsync, avoids data copy)
+    execSync(`cp -c -R "${sourcePath}" "${destinationPath}"`, {
+      stdio: 'pipe',
+      timeout: 300_000, // 5 min safety timeout
+    });
+
+    // Remove excluded items from the clone
+    for (const exclude of excludes) {
+      if (exclude.includes('*')) {
+        // Glob pattern — use shell expansion
+        try {
+          execSync(`rm -rf "${join(destinationPath, exclude)}"`, {
+            stdio: 'pipe',
+            shell: '/bin/sh',
+          });
+        } catch {
+          // Glob matched nothing — fine
+        }
+      } else {
+        const excludePath = join(destinationPath, exclude);
+        if (existsSync(excludePath)) {
+          rmSync(excludePath, { recursive: true, force: true });
+        }
+      }
+    }
+
+    if (!silent) {
+      console.log(
+        `Directory cloned (APFS CoW) from ${sourcePath} to ${destinationPath}`,
+      );
+    }
+    return true;
+  } catch {
+    // Clone failed (cross-volume, non-APFS, etc.) — fall back to rsync
+    // Clean up any partial clone
+    if (existsSync(destinationPath)) {
+      try {
+        rmSync(destinationPath, { recursive: true });
+      } catch {
+        // Best effort cleanup
+      }
+    }
+    return false;
+  }
+}
 
 export default async function rsyncCopy({
   sourcePath,
@@ -7,6 +90,7 @@ export default async function rsyncCopy({
   keepExisting = false,
   silent = false,
   extraArgs = [],
+  timeoutMs = 300_000,
 }: {
   sourcePath: string;
   destinationPath: string;
@@ -14,14 +98,41 @@ export default async function rsyncCopy({
   keepExisting?: boolean;
   silent?: boolean;
   extraArgs?: string[];
+  /** Timeout in milliseconds. Defaults to 300s (5 min). */
+  timeoutMs?: number;
 }): Promise<void> {
+  const startTime = Date.now();
+
+  // On macOS, try APFS copy-on-write clone first (near-instant).
+  // Skip when extraArgs are provided since those are rsync-specific flags
+  // that the clone path can't honor.
+  if (!keepExisting && extraArgs.length === 0) {
+    const cloned = tryApfsClone({
+      sourcePath,
+      destinationPath,
+      excludes,
+      silent,
+    });
+    if (cloned) {
+      if (!silent) {
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(
+          `Directory synced from ${sourcePath} to ${destinationPath} [Time: ${duration}s]`,
+        );
+      }
+      return;
+    }
+  }
+
+  // Fall back to rsync
   return new Promise((resolve, reject) => {
     const source = sourcePath.endsWith('/') ? sourcePath : `${sourcePath}/`;
     const dest = destinationPath.endsWith('/')
       ? destinationPath
       : `${destinationPath}/`;
 
-    const rsyncArgs = ['-a'];
+    // -a includes --specials which tries to copy sockets/FIFOs and can fail
+    const rsyncArgs = ['-a', '--no-specials'];
 
     if (!keepExisting) {
       rsyncArgs.push('--delete', '--force');
@@ -37,10 +148,29 @@ export default async function rsyncCopy({
 
     rsyncArgs.push(source, dest);
 
-    const startTime = Date.now();
     const rsyncProcess = spawn('rsync', rsyncArgs);
 
+    let settled = false;
+    const timer = timeoutMs
+      ? setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            rsyncProcess.kill('SIGKILL');
+            const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+            reject(
+              new Error(
+                `rsync timed out after ${duration}s syncing ${sourcePath} → ${destinationPath}`,
+              ),
+            );
+          }
+        }, timeoutMs)
+      : undefined;
+
     rsyncProcess.on('exit', (code) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+
       if (code === 0) {
         if (!silent) {
           const duration = ((Date.now() - startTime) / 1000).toFixed(1);
@@ -50,11 +180,26 @@ export default async function rsyncCopy({
         }
         resolve();
       } else {
+        console.error(
+          `CodeYam Error: rsync failed with code: ${code}`,
+          JSON.stringify(
+            {
+              rsyncArgs,
+            },
+            null,
+            2,
+          ),
+        );
+
         reject(new Error(`rsync failed with exit code ${code}`));
       }
     });
 
     rsyncProcess.on('error', (error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+
       if (!silent) {
         console.log('Error occurred:', error);
       }

package/analyzer-template/packages/utils/src/lib/safeFileName.ts

@@ -1,10 +1,55 @@
-export default function safeFileName(name: string) {
+/**
+ * Simple hash function for generating unique suffixes.
+ * Uses djb2 algorithm - fast and produces good distribution.
+ * Not cryptographically secure, but sufficient for filename uniqueness.
+ */
+function simpleHash(str: string): string {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash * 33) ^ str.charCodeAt(i);
+  }
+  // Convert to unsigned 32-bit and then to hex
+  return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+export interface SafeFileNameOptions {
+  /**
+   * Maximum length of the resulting filename.
+   * If the name exceeds this length, it will be truncated and a hash suffix added.
+   * macOS has a 255 byte filename limit. Default is undefined (no limit).
+   */
+  maxLength?: number;
+}
+
+export default function safeFileName(
+  name: string,
+  options: SafeFileNameOptions = {},
+): string {
+  const { maxLength } = options;
+
   // Replace unsafe characters with underscores, preserving original casing
   // Then trim leading/trailing underscores to avoid malformed route segments
-  const safeSlug = name.replace(/[^a-zA-Z0-9_]+/g, '_').replace(/^_+|_+$/g, '');
+  let safeSlug = name.replace(/[^a-zA-Z0-9_]+/g, '_').replace(/^_+|_+$/g, '');
 
   if (!safeSlug) return '';
 
   // Ensure it starts with a capital letter (for consistency with Remix routes)
-  return safeSlug.slice(0, 1).toUpperCase() + safeSlug.slice(1);
+  safeSlug = safeSlug.slice(0, 1).toUpperCase() + safeSlug.slice(1);
+
+  // If maxLength is specified and the slug exceeds it, truncate and add a hash
+  if (maxLength && safeSlug.length > maxLength) {
+    // Create an 8-character hash of the full name for uniqueness
+    const hash = simpleHash(name);
+
+    // Reserve space for underscore + hash (9 chars total)
+    const truncateLength = maxLength - 9;
+    const truncated = safeSlug.substring(0, truncateLength);
+
+    // Remove trailing underscore if present (from mid-word truncation)
+    const cleanTruncated = truncated.replace(/_+$/, '');
+
+    safeSlug = `${cleanTruncated}_${hash}`;
+  }
+
+  return safeSlug;
 }

package/analyzer-template/playwright/capture.ts

@@ -161,10 +161,10 @@ export default async function capture({
   awsLogDebugLevel(1, 'Capture process initialized, waiting for controller...');
 
   // Resolve controller URL once before starting capture loop
-  // Read controller port from log file (for local dev) or use PROJECT_URL env var (for Docker)
+  // Priority: PROJECT_URL env var > log file (local dev) > default (Docker)
   let controllerUrl = process.env.PROJECT_URL;
 
-  if (!controllerUrl) {
+  if (!controllerUrl && process.env.CODEYAM_LOCAL_PROJECT_PATH) {
     // Local dev mode - poll log file until controller port is found
     awsLog('CodeYam: Waiting for controller port in log file...');
     let controllerPort: number | null = null;
@@ -182,10 +182,19 @@ export default async function capture({
       awsLog('CodeYam: Shutdown during controller port wait');
       return;
     }
+  } else if (!controllerUrl) {
+    // Docker mode - use fixed port 3000
+    controllerUrl = 'http://localhost:3000';
+    awsLog(`Using default controller URL: ${controllerUrl}`);
   }
 
   awsLogDebugLevel(1, 'Controller found, waiting for analysis...');
 
+  // Determine if we're in local CLI mode vs cloud mode
+  // In local mode, connection failures indicate server crash (should exit quickly)
+  // In cloud mode, connection failures are normal between work items (wait patiently)
+  const isLocalMode = !!process.env.CODEYAM_LOCAL_PROJECT_PATH;
+
   // Track if we've ever successfully captured an analysis
   // If connection fails after we've successfully worked, it means controller exited
   let hasEverCapturedAnalysis = false;
@@ -248,11 +257,11 @@ export default async function capture({
           analysisId: analysis.id,
           entityName: analysis.entityName,
         });
-        await updateFreshAnalysisStatus(
+        await updateFreshAnalysisStatusWithScenarios(
           analysis.id,
-          (freshStatus, inAnalysis) => {
+          (freshStatus, dbScenarios, inAnalysis) => {
             // Mark any incomplete scenarios as errored
-            for (const scenario of inAnalysis.scenarios || []) {
+            for (const scenario of dbScenarios) {
               const scenarioStatus = freshStatus.scenarios?.find(
                 (s) => s.name === scenario.name,
               );
@@ -272,17 +281,18 @@ export default async function capture({
             }
 
             // Mark the analysis as finished if all scenarios have been addressed
-            const allScenariosComplete = freshStatus.scenarios?.every(
-              (s) => s.finishedAt || s.error,
-            );
+            // Only set finishedAt - the loader will exclude based on scenario states
+            const allScenariosComplete =
+              freshStatus.scenarios?.length >= dbScenarios.length &&
+              freshStatus.scenarios?.every((s) => s.finishedAt || s.error);
             if (allScenariosComplete && !freshStatus.finishedAt) {
               freshStatus.finishedAt = new Date().toISOString();
-              freshStatus.readyToBeCaptured = false;
               awsLog('CodeYam: Marking analysis as complete on shutdown', {
                 analysisId: inAnalysis.id,
               });
             }
           },
+          'capture-shutdown',
         );
       }
 
@@ -334,7 +344,13 @@ export default async function capture({
 
   async function captureOneAnalysis() {
     // controllerUrl is already set in parent scope - just wait for server to be ready
-    const waitResult = await waitForServer(controllerUrl, () => isShuttingDown);
+    const waitResult = await waitForServer(
+      controllerUrl,
+      () => isShuttingDown,
+      {
+        isLocalMode,
+      },
+    );
 
     // Check if controller signaled completion during wait
     if (waitResult.shutdown) {
@@ -372,23 +388,27 @@ export default async function capture({
           break;
         }
 
-        // Check if connection failed (controller may have exited)
+        // Check if connection failed (controller may have exited or not started yet)
         if (result.connectionFailed) {
-          consecutiveConnectionFailures++;
-          awsLog(
-            `CodeYam: Connection failed (attempt ${consecutiveConnectionFailures}/${MAX_CONNECTION_FAILURES_FOR_SHUTDOWN}, hasEverCaptured=${hasEverCapturedAnalysis})`,
-          );
-          // If we've had many consecutive connection failures, the controller has likely exited
-          // This can happen even if hasEverCapturedAnalysis is false due to race conditions
-          // in how scenario completion is tracked
-          if (
-            consecutiveConnectionFailures >=
-            MAX_CONNECTION_FAILURES_FOR_SHUTDOWN
-          ) {
-            awsLog('CodeYam: Controller connection lost, treating as shutdown');
-            isShuttingDown = true;
-            break;
+          // Only treat connection failures as shutdown in local mode
+          // In cloud mode, connection failures are expected between work items
+          if (isLocalMode) {
+            consecutiveConnectionFailures++;
+            awsLog(
+              `CodeYam: Connection failed (attempt ${consecutiveConnectionFailures}/${MAX_CONNECTION_FAILURES_FOR_SHUTDOWN}, hasEverCaptured=${hasEverCapturedAnalysis})`,
+            );
+            if (
+              consecutiveConnectionFailures >=
+              MAX_CONNECTION_FAILURES_FOR_SHUTDOWN
+            ) {
+              awsLog(
+                'CodeYam: Controller connection lost, treating as shutdown',
+              );
+              isShuttingDown = true;
+              break;
+            }
           }
+          // In cloud mode, just continue waiting (don't count failures)
         } else {
           consecutiveConnectionFailures = 0;
         }
@@ -531,7 +551,7 @@ export default async function capture({
 
           await updateFreshAnalysisStatusWithScenarios(
             analysis.id,
-            (freshStatus, scenarios) => {
+            (freshStatus, dbScenarios) => {
               freshStatus.scenarios ||= [];
               const scenarioStatus = freshStatus.scenarios.find(
                 (s) => s.name === scenario.name,
@@ -550,6 +570,17 @@ export default async function capture({
                   error: fullErrorMessage,
                 });
               }
+
+              // Check if all scenarios are now complete (even if with errors)
+              // Only set finishedAt - the loader will exclude this analysis based on
+              // the scenario check (all have finishedAt || error), no need to also
+              // toggle readyToBeCaptured which has different semantics
+              if (
+                freshStatus.scenarios.length >= dbScenarios.length &&
+                freshStatus.scenarios.every((s) => s.finishedAt || s.error)
+              ) {
+                freshStatus.finishedAt = new Date().toISOString();
+              }
             },
             'capture-http-error',
           );

package/analyzer-template/playwright/captureFromUrl.ts

@@ -22,6 +22,7 @@ interface CaptureArgs {
   projectId: string;
   projectRoot: string;
   viewportWidth?: number;
+  captureCurrentUrl?: boolean;
 }
 
 async function main() {
@@ -100,71 +101,6 @@ async function main() {
   }
   const projectSlug = project.slug;
 
-  // 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}`,
-  );
-
-  try {
-    // Load config to find which webapp this analysis belongs to
-    const configPath = path.join(projectRoot, '.codeyam', 'config.json');
-    const configData = await fs.readFile(configPath, 'utf-8');
-    const projectConfig = JSON.parse(configData);
-
-    const filePath = analysis.file.path;
-    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),
-    );
-
-    if (webapp) {
-      console.log(`[Capture] Found webapp: ${webapp.path}`);
-
-      // Construct the mocksDir path in the local dev environment
-      const localDevProjectPath = `/tmp/codeyam/local-dev/${projectSlug}/project`;
-      const mocksDir = path.join(
-        localDevProjectPath,
-        webapp.path,
-        webapp.appDirectory || 'app',
-        '__codeyamMocks__',
-      );
-
-      console.log(`[Capture] MockData.tsx directory: ${mocksDir}`);
-
-      // Ensure the analysis has its scenarios attached
-      const analysisWithScenarios = {
-        ...analysis,
-        scenarios: analysis.scenarios || [scenario],
-      };
-
-      // If the current scenario isn't in the scenarios array, add it
-      if (!analysisWithScenarios.scenarios.find((s) => s.id === scenario.id)) {
-        analysisWithScenarios.scenarios.push(scenario);
-      }
-
-      await writeMockDataTsx(analysisWithScenarios, scenario, mocksDir);
-      console.log(`[Capture] MockData.tsx regenerated successfully`);
-
-      // 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));
-      console.log(`[Capture] Proceeding with screenshot capture`);
-    } else {
-      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,
-    );
-    // 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
@@ -186,27 +122,98 @@ async function main() {
 
   await fs.mkdir(capturesDir, { recursive: true });
 
-  // Take screenshot
-  console.log(`[Capture] Taking screenshot of: ${url}`);
+  // Helper: take screenshot and verify
+  const captureScreenshot = async () => {
+    console.log(`[Capture] Taking screenshot of: ${url}`);
+
+    const result = await takeElementScreenshot({
+      url,
+      selector: '#component',
+      screenshotPath,
+      viewportWidth,
+      blockPatterns: ['fonts.googleapis.com', 'fonts.gstatic.com'],
+    });
+
+    if (!result.screenshotTaken) {
+      console.error(`[Capture] ERROR: Screenshot was not taken`);
+      process.exit(1);
+    }
 
-  const result = await takeElementScreenshot({
-    url,
-    selector: '#component',
-    screenshotPath,
-    viewportWidth,
-    blockPatterns: ['fonts.googleapis.com', 'fonts.gstatic.com'],
-  });
+    console.log(`[Capture] Screenshot taken successfully`);
 
-  if (!result.screenshotTaken) {
-    console.error(`[Capture] ERROR: Screenshot was not taken`);
-    process.exit(1);
-  }
+    const stats = await fs.stat(screenshotPath);
+    console.log(`[Capture] File saved: ${stats.size} bytes`);
+  };
+
+  // Helper: regenerate MockData.tsx
+  const regenerateMockData = async () => {
+    console.log(
+      `[Capture] Regenerating MockData.tsx for scenario: ${scenario.name}`,
+    );
 
-  console.log(`[Capture] Screenshot taken successfully`);
+    try {
+      const configPath = path.join(projectRoot, '.codeyam', 'config.json');
+      const configData = await fs.readFile(configPath, 'utf-8');
+      const projectConfig = JSON.parse(configData);
 
-  // Verify file was written
-  const stats = await fs.stat(screenshotPath);
-  console.log(`[Capture] File saved: ${stats.size} bytes`);
+      const filePath = analysis.file!.path;
+      console.log(`[Capture] Analysis file path: ${filePath}`);
+
+      const webapp = projectConfig.webapps?.find((w: { path: string }) =>
+        filePath.startsWith(w.path),
+      );
+
+      if (webapp) {
+        console.log(`[Capture] Found webapp: ${webapp.path}`);
+
+        const localDevProjectPath = `/tmp/codeyam/local-dev/${projectSlug}/project`;
+        const mocksDir = path.join(
+          localDevProjectPath,
+          webapp.path,
+          webapp.appDirectory || 'app',
+          '__codeyamMocks__',
+        );
+
+        console.log(`[Capture] MockData.tsx directory: ${mocksDir}`);
+
+        const analysisWithScenarios = {
+          ...analysis,
+          scenarios: analysis.scenarios || [scenario],
+        };
+
+        if (
+          !analysisWithScenarios.scenarios.find((s) => s.id === scenario.id)
+        ) {
+          analysisWithScenarios.scenarios.push(scenario);
+        }
+
+        await writeMockDataTsx(analysisWithScenarios, scenario, mocksDir);
+        console.log(`[Capture] MockData.tsx regenerated successfully`);
+      } else {
+        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,
+      );
+    }
+  };
+
+  if (config.captureCurrentUrl) {
+    // Capture what's currently displayed first, then create MockData for future use
+    await captureScreenshot();
+    await regenerateMockData();
+  } else {
+    // Default: regenerate first, wait for HMR, then capture
+    await regenerateMockData();
+    console.log(`[Capture] Waiting for dev server to reload...`);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    console.log(`[Capture] Proceeding with screenshot capture`);
+    await captureScreenshot();
+  }
 
   // Update scenario metadata with new screenshot path
   const updatedMetadata = {

package/analyzer-template/playwright/captureStatic.ts

@@ -40,7 +40,7 @@ export default async function captureStatic({
       const now = new Date().toISOString();
       await updateCommitMetadata({
         commitId: analysis.commitId,
-        updateCallback: (metadata, commit) => {
+        updateCallback: (metadata) => {
           if (metadata.currentRun) {
             metadata.currentRun.firstCaptureAt ??= now;
             metadata.currentRun.lastCaptureAt = now;

package/analyzer-template/playwright/getCodeYamInfo.ts

@@ -1,5 +1,3 @@
-/* eslint-disable */
-
 import { ProjectFramework } from '~codeyam/types';
 
 export interface CodeYamInfo {
@@ -41,7 +39,9 @@ export default async function getCodeYamInfo(
 
       // if controller signals complete, tell capture to shut down
       if (phase === 'COMPLETE') {
-        console.log(`CodeYam DEBUG: getCodeYamInfo received COMPLETE phase, signaling shutdown`);
+        console.log(
+          `CodeYam DEBUG: getCodeYamInfo received COMPLETE phase, signaling shutdown`,
+        );
         if (options?.returnShutdown) {
           return { info: null, shutdown: true };
         }
@@ -57,7 +57,6 @@ export default async function getCodeYamInfo(
       }
 
       // all other cases mean 'keep waiting'
-      console.log(`CodeYam DEBUG: getCodeYamInfo phase=${phase}, info=${info ? 'present' : 'null'}, returning null`);
       if (options?.returnShutdown) {
         return { info: null, shutdown: false };
       }
@@ -74,7 +73,9 @@ export default async function getCodeYamInfo(
     const errorMessage = error.message || '';
     const causeMessage = error.cause?.message || '';
 
-    console.log(`CodeYam DEBUG: getCodeYamInfo caught error - code=${errorCode}, message=${errorMessage}, causeMessage=${causeMessage}`);
+    console.log(
+      `CodeYam DEBUG: getCodeYamInfo caught error - code=${errorCode}, message=${errorMessage}, causeMessage=${causeMessage}`,
+    );
 
     const isConnectionError =
       errorCode === 'ECONNREFUSED' ||
@@ -85,11 +86,15 @@ export default async function getCodeYamInfo(
       causeMessage.includes('ECONNREFUSED');
 
     if (!isConnectionError) {
-      console.log(`CodeYam DEBUG: getCodeYamInfo error is NOT a connection error, rethrowing`);
+      console.log(
+        `CodeYam DEBUG: getCodeYamInfo error is NOT a connection error, rethrowing`,
+      );
       throw error;
     }
     // let caller know the server just isn't up yet (or has shut down)
-    console.log(`CodeYam DEBUG: getCodeYamInfo connection error detected, returning connectionFailed=true`);
+    console.log(
+      `CodeYam DEBUG: getCodeYamInfo connection error detected, returning connectionFailed=true`,
+    );
     if (options?.returnShutdown) {
       return { info: null, shutdown: false, connectionFailed: true };
     }