@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.e38f7bd

package/analyzer-template/packages/utils/src/lib/frameworks/frameworkRouteFileNameToRoute.ts

@@ -4,18 +4,37 @@ import isNextRoute from './isNextRoute';
 import remixRouteFileNameToRoute from './remixRouteFileNameToRoute';
 import nextRouteFileNameToRoute from './nextRouteFileNameToRoute';
 
+/**
+ * Generate a URL path for a framework route file.
+ *
+ * @param projectSlug - The project slug
+ * @param file - The route file
+ * @param analysis - The analysis for the entity
+ * @param framework - The project framework
+ * @param scenarioName - Optional scenario name to include in path
+ * @param routeParams - Optional map of param names to values for dynamic segments.
+ *                      If provided, [param] segments are substituted with actual values.
+ *                      If not provided, [param] segments are preserved for folder creation.
+ */
 export default function frameworkRouteFileNameToRoute(
   projectSlug: string,
   file: File,
   analysis: Analysis,
   framework: ProjectFramework,
   scenarioName?: string,
+  routeParams?: Record<string, string | string[]>,
 ) {
   if (isRemixRoute(file, analysis.entity, framework)) {
     return remixRouteFileNameToRoute(projectSlug, file, analysis, scenarioName);
   }
 
   if (isNextRoute(file, analysis.entity, framework)) {
-    return nextRouteFileNameToRoute(projectSlug, file, analysis, scenarioName);
+    return nextRouteFileNameToRoute(
+      projectSlug,
+      file,
+      analysis,
+      scenarioName,
+      routeParams,
+    );
   }
 }

package/analyzer-template/packages/utils/src/lib/frameworks/nextRouteFileNameToRoute.ts

@@ -2,13 +2,28 @@ import { Analysis, File } from '~codeyam/types';
 import safeFileName from '../safeFileName';
 import sanitizeNextRouteSegments from './sanitizeNextRouteSegments';
 
+/**
+ * Generate a URL path for a Next.js route file.
+ *
+ * @param projectSlug - The project slug
+ * @param file - The route file (page.tsx, layout.tsx, etc.)
+ * @param analysis - The analysis for the entity
+ * @param scenarioName - Optional scenario name to include in path
+ * @param routeParams - Optional map of param names to values for dynamic segments.
+ *                      If provided, [param] segments are substituted with actual values.
+ *                      If not provided, [param] segments are preserved for folder creation.
+ */
 export default function nextRouteFileNameToRoute(
   projectSlug: string,
   file: File,
   analysis: Analysis,
   scenarioName?: string,
+  routeParams?: Record<string, string | string[]>,
 ) {
-  const route = sanitizeNextRouteSegments(file.path.split('/').slice(1, -1));
+  const route = sanitizeNextRouteSegments(
+    file.path.split('/').slice(1, -1),
+    routeParams,
+  );
   const pathComponents = [
     'static',
     projectSlug,

package/analyzer-template/packages/utils/src/lib/frameworks/sanitizeNextRouteSegments.ts

@@ -1,15 +1,25 @@
 /**
- * Sanitize Next.js route path segments to remove special syntax.
+ * Sanitize Next.js route path segments for use in URLs or folder paths.
+ *
+ * Behavior depends on whether routeParams is provided:
+ *
+ * WITH routeParams (for URL generation):
+ * - Route groups (folder) become folder (strip parens, keep name)
+ * - Dynamic segments [param] are substituted with actual values from routeParams
+ * - Catch-all [...slug] values (arrays) are joined with '/'
+ * - Missing params fall back to preserving the bracket syntax
+ *
+ * WITHOUT routeParams (for folder creation):
  * - Route groups (folder) become folder (strip parens, keep name)
- * - Dynamic segments [param] become param0 (suffix avoids Next.js private folder convention)
- * - Catch-all [...slug] becomes slug0
- * - Optional catch-all [[...slug]] becomes slug0
+ * - Dynamic segments [param], [...slug], [[...slug]] are preserved as-is
+ *   so Next.js recognizes them as dynamic routes and populates params
  *
- * Note: We use suffix "0" instead of prefix "_" because Next.js treats folders
- * starting with underscore as private segments that are excluded from routing.
+ * @param segments - Array of path segments (e.g., ['app', '[environmentId]', 'page.tsx'])
+ * @param routeParams - Optional map of param names to values for URL substitution
  */
 export default function sanitizeNextRouteSegments(
   segments: string[],
+  routeParams?: Record<string, string | string[]>,
 ): string[] {
   return segments.map((segment) => {
     // Handle route groups (folder) - strip parens, keep name
@@ -18,15 +28,39 @@ export default function sanitizeNextRouteSegments(
 
     // Handle optional catch-all [[...param]]
     const optionalCatchAll = segment.match(/^\[\[\.\.\.([\w]+)\]\]$/);
-    if (optionalCatchAll) return `${optionalCatchAll[1]}0`;
+    if (optionalCatchAll) {
+      const paramName = optionalCatchAll[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     // Handle catch-all [...param]
     const catchAll = segment.match(/^\[\.\.\.([\w]+)\]$/);
-    if (catchAll) return `${catchAll[1]}0`;
+    if (catchAll) {
+      const paramName = catchAll[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     // Handle dynamic [param]
     const dynamic = segment.match(/^\[([\w]+)\]$/);
-    if (dynamic) return `${dynamic[1]}0`;
+    if (dynamic) {
+      const paramName = dynamic[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     return segment;
   });

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

@@ -121,6 +121,22 @@ export function extractEntitiesFromContent(
           entityType: 'unknown',
           isDefault: true,
         });
+      } else if (ts.isExportDeclaration(node) && node.exportClause) {
+        // Handle re-exports: export { foo, bar } from './module'
+        // and named exports: export { foo, bar }
+        if (ts.isNamedExports(node.exportClause)) {
+          const code = node.getText(sourceFile);
+          for (const element of node.exportClause.elements) {
+            const exportedName = element.name.text;
+            entities.push({
+              name: exportedName,
+              code,
+              sha: generateSha(filePath, exportedName, code),
+              entityType: 'unknown',
+              isDefault: false,
+            });
+          }
+        }
       }
 
       ts.forEachChild(node, visit);

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

@@ -1,6 +1,9 @@
 export default function safeFileName(name: string) {
   // Replace unsafe characters with underscores, preserving original casing
-  const safeSlug = name.replace(/[^a-zA-Z0-9_]+/g, '_');
+  // Then trim leading/trailing underscores to avoid malformed route segments
+  const 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);

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

@@ -0,0 +1,63 @@
+import { WebApp, EnvironmentVariable } from '~codeyam/types';
+
+export interface BuildStartCommandOptions {
+  webapp: WebApp | undefined;
+  port: number;
+  environmentVariables: EnvironmentVariable[];
+  packageManager: string;
+}
+
+/**
+ * Builds a shell-ready start command string for a webapp.
+ *
+ * This function handles:
+ * - $PORT substitution in args and env vars
+ * - Environment variable formatting with proper escaping
+ * - sh -c command quoting
+ * - Fallback when no startCommand is configured
+ */
+export default function buildStartCommand(
+  options: BuildStartCommandOptions,
+): string {
+  const { webapp, port, environmentVariables, packageManager } = options;
+  const startCmd = webapp?.startCommand;
+
+  // Fallback when no startCommand configured
+  if (!startCmd) {
+    return `${packageManager} ${packageManager === 'npm' ? 'run ' : ''}dev`;
+  }
+
+  // Substitute $PORT in args
+  const args =
+    startCmd.args?.map((arg: string) => arg.replace(/\$PORT/g, String(port))) ??
+    [];
+
+  // Build environment variables string from config
+  const envVars: string[] = [];
+  for (const envVar of environmentVariables) {
+    if (envVar.key && envVar.value !== undefined) {
+      // Escape single quotes in values
+      const escapedValue = String(envVar.value).replace(/'/g, "'\\''");
+      envVars.push(`${envVar.key}='${escapedValue}'`);
+    }
+  }
+
+  // Add any env vars from startCommand.env
+  if (startCmd.env) {
+    for (const [key, value] of Object.entries(startCmd.env)) {
+      const substitutedValue = String(value).replace(/\$PORT/g, String(port));
+      const escapedValue = substitutedValue.replace(/'/g, "'\\''");
+      envVars.push(`${key}='${escapedValue}'`);
+    }
+  }
+
+  const envPrefix = envVars.length > 0 ? envVars.join(' ') + ' ' : '';
+
+  // If command is 'sh' with '-c' arg, properly quote the shell command
+  if (startCmd.command === 'sh' && args[0] === '-c' && args[1]) {
+    return `${envPrefix}sh -c "${args[1]}"`;
+  }
+
+  // Default: just join command and args
+  return `${envPrefix}${startCmd.command} ${args.join(' ')}`;
+}

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

@@ -0,0 +1,108 @@
+import { WebApp, EnvironmentVariable, ProjectFramework } from '~codeyam/types';
+import buildStartCommand from './buildStartCommand';
+import * as path from 'path';
+
+export interface GetWebappInfoOptions {
+  filePath: string;
+  webapps: WebApp[];
+  environmentVariables: EnvironmentVariable[];
+  port: number;
+  packageManager: string;
+}
+
+export interface WebappInfo {
+  webapp: WebApp;
+  webappPath: string;
+  framework: ProjectFramework;
+  packageManager: string;
+  startCommand: string;
+  url: string;
+}
+
+/**
+ * Find which webapp a component belongs to based on its file path.
+ * Returns the webapp with the most specific (longest) path match.
+ */
+function findWebAppForComponent(
+  componentPath: string,
+  webapps: WebApp[],
+): WebApp | undefined {
+  if (!webapps || webapps.length === 0) {
+    return undefined;
+  }
+
+  if (webapps.length === 1) {
+    return webapps[0];
+  }
+
+  // Normalize the component path
+  const normalizedComponentPath = path.normalize(componentPath);
+
+  // Sort webapps by path length (descending) to match most specific path first
+  const sortedWebapps = [...webapps].sort(
+    (a, b) => (b.path?.length ?? 0) - (a.path?.length ?? 0),
+  );
+
+  // Find the webapp whose path is a prefix of the component path
+  for (const webapp of sortedWebapps) {
+    const webappPath = path.normalize(webapp.path ?? '.');
+
+    // Check if component is within this webapp
+    if (webappPath === '.') {
+      // Root webapp - matches everything (but we check others first due to sorting)
+      return webapp;
+    }
+
+    // Check if component path starts with webapp path
+    if (
+      normalizedComponentPath.startsWith(webappPath + path.sep) ||
+      normalizedComponentPath === webappPath
+    ) {
+      return webapp;
+    }
+  }
+
+  // Fallback to first webapp
+  return webapps[0];
+}
+
+/**
+ * Gets comprehensive webapp information for a given file path.
+ *
+ * This function:
+ * - Finds the correct webapp for the file path
+ * - Builds the complete start command with environment variables
+ * - Returns all relevant webapp metadata
+ */
+export default function getWebappInfo(
+  options: GetWebappInfoOptions,
+): WebappInfo {
+  const { filePath, webapps, environmentVariables, port, packageManager } =
+    options;
+
+  if (!webapps || webapps.length === 0) {
+    throw new Error('No webapps configured. Please run CodeYam init again.');
+  }
+
+  const webapp = findWebAppForComponent(filePath, webapps);
+
+  if (!webapp) {
+    throw new Error('Could not find webapp for file path: ' + filePath);
+  }
+
+  const startCommand = buildStartCommand({
+    webapp,
+    port,
+    environmentVariables,
+    packageManager,
+  });
+
+  return {
+    webapp,
+    webappPath: webapp.path ?? '.',
+    framework: webapp.framework,
+    packageManager: webapp.packageManager ?? packageManager,
+    startCommand,
+    url: `http://localhost:${port}/static/codeyam-sample`,
+  };
+}

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