@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee

package/analyzer-template/project/startServer.ts

@@ -0,0 +1,188 @@
+import getPort from 'get-port';
+import execAsync from '../common/execAsync';
+import { ProjectFramework, ServerCommand } from '~codeyam/types';
+import { Socket } from 'net';
+import { awsLogDebugLevel } from '~codeyam/utils';
+
+export interface StartServerArgs {
+  startCommand?: ServerCommand;
+  packageManager: string;
+  exitAfterSuccessfulAppStart?: boolean;
+  onStart: (port: number) => Promise<void>;
+  onError: (data: string) => Promise<void>;
+  framework: ProjectFramework;
+  projectPort?: number;
+}
+
+export async function startServer({
+  startCommand,
+  packageManager,
+  onStart,
+  onError,
+  framework,
+  projectPort,
+}: StartServerArgs) {
+  const acceptableErrorsRegexes = [
+    /robots\.txt/,
+    /favicon\.ico/,
+    /DeprecationWarning/,
+    /warn deprecated/,
+    /One of your dependencies, babel-preset-react-app, is importing the/, // This error is thrown in CRA and is not a problem. TODO: How to not throw for warnings
+    /No route matches URL/,
+    /Browserslist: caniuse-lite is outdated/,
+    /npx update-browserslist-db@latest/,
+    /It appears you've configured a `sentry.server.config.js` file/,
+    /Watchpack Error \(watcher\): Error: ENOSPC: System limit for number of file watchers reached/,
+    /Your project has\s+`([^`]+)`\s+installed as a dependency,\s+please use the built-in/,
+  ];
+
+  try {
+    // both 'undefined' and 0 triggers port auto-selection, which we do here as late as
+    // possible to mimimise the risk of race conditions & port conflicts downstream
+    if (!projectPort) {
+      projectPort = await getPort();
+      console.log(`CodeYam: Auto-selected project port: ${projectPort}`);
+    }
+
+    // Check if port is open using TCP
+    const checkPort = async (port: number): Promise<boolean> => {
+      return new Promise((resolve) => {
+        const socket = new Socket();
+        const timer: { current?: ReturnType<typeof setTimeout> } = {};
+
+        socket.once('error', (err: Error) => {
+          if ((err as NodeJS.ErrnoException).code !== 'ECONNREFUSED') {
+            console.log(
+              `CodeYam: checkPort: Error connecting to port ${port}: ${err.message}`,
+            );
+          }
+          if (timer.current) clearTimeout(timer.current);
+          socket.destroy();
+          resolve(false);
+        });
+        socket.once('connect', () => {
+          if (timer.current) clearTimeout(timer.current);
+          socket.destroy();
+          resolve(true);
+        });
+
+        socket.connect(port, 'localhost');
+
+        // Don't leave socket hanging
+        timer.current = setTimeout(() => {
+          console.log(`CodeYam: checkPort: Timeout`);
+          socket.destroy();
+          resolve(false);
+        }, 300);
+      });
+    };
+
+    // Health check that polls the port
+    const waitForPort = async () => {
+      while (true) {
+        if (await checkPort(projectPort)) {
+          await onStart(projectPort);
+          // Keep promise pending to let execAsync control lifecycle
+          await new Promise(() => {});
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    };
+
+    // figure out the right CLI invocation for starting the server
+    const command = startCommand?.command ?? packageManager;
+    let args = startCommand?.args;
+
+    if (args) {
+      // Custom startCommand provided - clone and process it
+      args = [...args];
+
+      // Replace any $PORT placeholders with the actual port
+      let hasPort = false;
+      for (let i = 0; i < args.length; i++) {
+        if (args[i].includes('$PORT')) {
+          args[i] = args[i].replace('$PORT', projectPort.toString());
+          hasPort = true;
+        } else if (args[i] === '--port' || args[i] === '-p') {
+          hasPort = true;
+        }
+      }
+
+      // If no port argument exists, add it.
+      // Use -- separator for compatibility with Turbo-based projects.
+      if (!hasPort) {
+        if (framework === ProjectFramework.Remix) {
+          args.push('--', '--port', projectPort.toString(), '--strictPort');
+        } else {
+          args.push('--', '--port', projectPort.toString());
+        }
+      }
+    } else {
+      if (framework === ProjectFramework.CodeYam) {
+        args = ['start', projectPort.toString()];
+      } else {
+        // there's no guarantee that the logic below will work for all frameworks, and
+        // certainly no guarantee that it'll work on any one individual project... but
+        // it's a reasonable default, and we have `startCommand` for anything bespoke
+        //
+        // All package managers support -- to pass arguments to scripts.
+        // npm requires it, and Turbo-based projects (monorepos) also require it.
+        // Using -- universally is safe and ensures compatibility.
+        args = ['run', 'dev', '--', '--port', projectPort.toString()];
+        if (framework === ProjectFramework.Remix) {
+          args.push('--strictPort');
+        }
+      }
+    }
+    let env = startCommand?.env;
+    if (!env) {
+      env = {
+        LOCAL: 'local',
+        PORT: projectPort.toString(),
+      };
+      if (framework === ProjectFramework.CRA) {
+        env.BROWSER = 'none';
+      }
+    } else {
+      // Replace $PORT placeholders in env values
+      env = { ...env };
+      for (const key of Object.keys(env)) {
+        if (typeof env[key] === 'string' && env[key].includes('$PORT')) {
+          env[key] = env[key].replace('$PORT', projectPort.toString());
+        }
+      }
+    }
+
+    awsLogDebugLevel(
+      2,
+      `Starting project server with command: ${command} ${args.join(' ')}`,
+    );
+
+    // Run execAsync and port check in parallel
+    const response = await Promise.race([
+      execAsync({
+        command,
+        args,
+        env,
+        workingDir: '../project',
+        acceptableErrorsRegexes,
+        // logErrors: false, // we do more selective logging ourselves
+        onError,
+        processName: 'local-project-server',
+      }),
+      waitForPort(),
+    ]);
+
+    console.log(
+      `CodeYam [DEBUG]: startServer: execAsync response: ${response.code}`,
+    );
+
+    // If execAsync completes first, return non-zero if server didn't bind port
+    return response.code === 0 ? 1 : response.code;
+  } catch (error) {
+    console.log(
+      `CodeYam Error: Error executing start script: ${error.message}`,
+    );
+    throw error; // Rethrow the error to be caught in the main function
+  }
+}

package/analyzer-template/project/updateCommitBackgroundJob.ts

@@ -0,0 +1,16 @@
+import { updateBackgroundJobProgress } from '~codeyam/supabase';
+import { BackgroundJob } from '~codeyam/types';
+export default async function updateCommitBackgroundJob(
+  backgroundJob: BackgroundJob,
+  stepName: string,
+) {
+  backgroundJob = await updateBackgroundJobProgress(backgroundJob, {
+    initiated: new Date().toISOString(),
+    steps: [
+      {
+        name: stepName,
+        initiated: new Date().toISOString(),
+      },
+    ],
+  });
+}

package/analyzer-template/project/utils/errorHandling.ts

@@ -0,0 +1,48 @@
+import { Analysis, Scenario } from '~codeyam/types';
+import emailErrorReport from '../emailErrorReport';
+import { updateFreshAnalysisStatus } from '~codeyam/supabase';
+
+export async function recordErrorMessageForScenario(
+  analysis: Analysis,
+  scenario: Scenario,
+  error: Error,
+  shouldEmailReport = true,
+) {
+  try {
+    await updateFreshAnalysisStatus(analysis.id, (freshStatus, _inAnalysis) => {
+      try {
+        freshStatus.scenarios ||= [];
+        const scenarioIndex = freshStatus.scenarios.findIndex(
+          (s) => s.name === scenario.name,
+        );
+        if (scenarioIndex === -1) {
+          freshStatus.scenarios.push({
+            name: scenario.name,
+            startedAt: new Date().toISOString(),
+            finishedAt: new Date().toISOString(),
+            error: error.message,
+          });
+        } else {
+          freshStatus.scenarios[scenarioIndex].error = error.message;
+          freshStatus.scenarios[scenarioIndex].finishedAt =
+            new Date().toISOString();
+        }
+      } catch (e) {
+        console.log(
+          'CodeYam Error: Error recording error message for scenario in fresh analysis',
+          e,
+        );
+      }
+    });
+
+    if (shouldEmailReport) {
+      await emailErrorReport({
+        analysis,
+        scenario,
+        errorMessage: error.message,
+      });
+    }
+  } catch (e) {
+    console.log('CodeYam Error: Error recording error message for scenario', e);
+  }
+}

package/analyzer-template/project/utils/mergeEnvVarsIntoStartCommand.ts

@@ -0,0 +1,50 @@
+import type { EnvironmentVariable, ServerCommand } from '~codeyam/types';
+
+/**
+ * Merges environment variables from project config into a start command.
+ *
+ * If a base command exists, the env vars are merged into it (config vars first,
+ * then command-specific vars override).
+ *
+ * If no base command exists but env vars are provided, creates a minimal command
+ * using package manager defaults with the env vars attached.
+ *
+ * @param baseStartCommand - The existing start command (may be undefined)
+ * @param environmentVariables - Environment variables from project config
+ * @param packageManager - Package manager to use for default command if needed
+ * @returns The merged start command, or undefined if no env vars and no base command
+ */
+export default function mergeEnvVarsIntoStartCommand(
+  baseStartCommand: ServerCommand | undefined,
+  environmentVariables: EnvironmentVariable[] | undefined,
+  packageManager: string,
+): ServerCommand | undefined {
+  // Build environment variables from config
+  const configEnvVars: Record<string, string> = {};
+  for (const envVar of environmentVariables || []) {
+    if (envVar.key && envVar.value !== undefined) {
+      configEnvVars[envVar.key] = envVar.value;
+    }
+  }
+
+  // No env vars to merge - return original command as-is
+  if (Object.keys(configEnvVars).length === 0) {
+    return baseStartCommand;
+  }
+
+  // If we have a base command, merge env vars into it
+  if (baseStartCommand) {
+    return {
+      ...baseStartCommand,
+      env: { ...configEnvVars, ...baseStartCommand.env },
+    };
+  }
+
+  // No explicit start command, but we need to pass env vars
+  // Create a command using package manager defaults
+  return {
+    command: packageManager,
+    args: packageManager === 'npm' ? ['run', 'dev'] : ['dev'],
+    env: configEnvVars,
+  };
+}

package/analyzer-template/project/utils/webappMapping.ts

@@ -0,0 +1,95 @@
+import { WebApp, ServerCommand, ProjectFramework } from '~codeyam/types';
+import * as path from 'path';
+
+/**
+ * Find which webapp a component belongs to based on its file path
+ * Returns the webapp that contains the component, or the first webapp as fallback
+ */
+export 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 - a.path.length,
+  );
+
+  // 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
+      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];
+}
+
+/**
+ * Get the start command for a component based on its file path
+ * Uses webapp mapping to find the correct webapp and return its start command
+ */
+export function getStartCommandForComponent(
+  componentPath: string,
+  webapps: WebApp[] | undefined,
+): ServerCommand | undefined {
+  if (!webapps || webapps.length === 0) {
+    throw new Error('No webapps configured. Please run CodeYam init again.');
+  }
+
+  // Find the webapp for this component
+  const webapp = findWebAppForComponent(componentPath, webapps);
+
+  if (!webapp) {
+    // Fallback to first webapp
+    return webapps[0].startCommand;
+  }
+
+  return webapp.startCommand;
+}
+
+/**
+ * Get the framework for a component based on its file path
+ * Uses webapp mapping to find the correct webapp and return its framework
+ */
+export function getFrameworkForComponent(
+  componentPath: string,
+  webapps: WebApp[] | undefined,
+): ProjectFramework {
+  if (!webapps || webapps.length === 0) {
+    throw new Error('No webapps configured. Please run CodeYam init again.');
+  }
+
+  // Find the webapp for this component
+  const webapp = findWebAppForComponent(componentPath, webapps);
+
+  if (!webapp) {
+    // Fallback to first webapp
+    return webapps[0].framework;
+  }
+
+  return webapp.framework;
+}

package/analyzer-template/project/writeCodeYamPage.ts

@@ -0,0 +1,32 @@
+import { Analysis, Scenario, ProjectFramework, Project } from '~codeyam/types';
+import writeFile from '../common/writeFile';
+import generateCodeYamPage from './generateCodeYamPage';
+import getCodeYamPagePath from './getCodeYamPagePath';
+
+export default async function writeCodeYamPage(
+  project: Project,
+  analysis: Analysis,
+  scenarios: Scenario[],
+  framework: ProjectFramework,
+  controllerPort?: number,
+) {
+  const { file } = analysis;
+  const path = getCodeYamPagePath({
+    project,
+    framework,
+    analysisFilePath: analysis.filePath,
+  });
+  const content = generateCodeYamPage({
+    project,
+    file,
+    analysis,
+    scenarios,
+    framework,
+    controllerPort,
+  });
+
+  console.log('CodeYam: Writing CodeYam page', path);
+  await writeFile(path, content);
+
+  return path;
+}

package/analyzer-template/project/writeEnv.ts

@@ -0,0 +1,54 @@
+import path from 'path';
+import fs from 'fs';
+import writeFile from '../common/writeFile';
+import { PROJECT_RELATIVE_PATH } from '~codeyam/utils';
+
+interface WriteEnvOptions {
+  /** Additional environment variables to include */
+  additionalVars?: Record<string, string>;
+}
+
+/**
+ * Prepends CodeYam environment variables to the existing .env file.
+ * Preserves existing sanitized values while adding the simulation marker.
+ */
+export default async function writeEnv(options?: WriteEnvOptions) {
+  const vars: Record<string, string> = {
+    CODEYAM_SIMULATION_VERSION: '1',
+    ...(options?.additionalVars ?? {}),
+  };
+
+  const envPath = path.join(PROJECT_RELATIVE_PATH, '.env');
+  const absoluteEnvPath = path.resolve(process.cwd(), envPath);
+
+  // Read existing .env content if it exists
+  let existingContent = '';
+  try {
+    if (fs.existsSync(absoluteEnvPath)) {
+      existingContent = fs.readFileSync(absoluteEnvPath, 'utf-8');
+    }
+  } catch {
+    // If we can't read it, we'll just create a new one
+  }
+
+  // Build the new vars as a header block
+  const headerLines = [
+    '# **************** !!WARN!! KEYS NOT AVAILABLE IN .env.example ****************',
+    ...Object.entries(vars).map(([key, value]) => `  ${key}=${value}`),
+    '# *****************************************************************************',
+    '',
+  ];
+
+  // Remove any existing CodeYam header block from the content
+  const cleanedContent = existingContent
+    .replace(/# \*+ !!WARN!! KEYS NOT AVAILABLE.*?# \*+\n*/s, '')
+    .trim();
+
+  // Combine header with existing content
+  const content =
+    cleanedContent.length > 0
+      ? headerLines.join('\n') + '\n\n' + cleanedContent
+      : headerLines.join('\n');
+
+  await writeFile(envPath, content);
+}

package/analyzer-template/project/writeLibComponent.ts

@@ -0,0 +1,50 @@
+import writeFile from '../common/writeFile';
+import type {
+  Analysis,
+  Scenario,
+  ProjectFramework,
+  Project,
+} from '~codeyam/types';
+import { libDemoComponent } from '~codeyam/generate';
+import {
+  safeFileName,
+  CODEYAM_DEMO_PAGES_DIRNAME,
+  PROJECT_RELATIVE_PATH,
+} from '~codeyam/utils';
+import getAppPath from './getAppPath';
+
+export default async function writeLibComponent(
+  project: Project,
+  analysis: Analysis,
+  scenario: Scenario,
+  framework: ProjectFramework,
+) {
+  const { file, entity } = analysis;
+
+  if (entity.entityType !== 'library') return;
+
+  const appPath = getAppPath(project, framework, false, file.path);
+
+  const componentName = safeFileName(entity.name);
+
+  const libComponentPath = `${appPath}/${CODEYAM_DEMO_PAGES_DIRNAME}/${entity.sha}_${componentName}.tsx`;
+  const relativeLibComponentPath = libComponentPath.replace(
+    PROJECT_RELATIVE_PATH + '/',
+    '',
+  );
+  const libComponentContent = libDemoComponent(
+    file,
+    entity,
+    analysis,
+    scenario,
+    relativeLibComponentPath,
+    appPath,
+  );
+
+  console.log('Codeyam: Writing lib component file', libComponentPath);
+  await writeFile(libComponentPath, libComponentContent);
+
+  console.log('CodeYam: Lib Components Complete');
+
+  return libComponentPath;
+}