@codeyam/codeyam-cli 0.1.0-staging.2a88920 → 0.1.0-staging.415103

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,
@@ -15,13 +98,38 @@ export default async function rsyncCopy({
   silent?: boolean;
   extraArgs?: string[];
 }): 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,7 +145,6 @@ export default async function rsyncCopy({
 
     rsyncArgs.push(source, dest);
 
-    const startTime = Date.now();
     const rsyncProcess = spawn('rsync', rsyncArgs);
 
     rsyncProcess.on('exit', (code) => {
@@ -50,6 +157,17 @@ 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}`));
       }
     });

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 = {