@codeyam/codeyam-cli 0.0.0 → 0.1.0-staging.036391e

package/analyzer-template/packages/generate/src/lib/directExecutionScript.ts

@@ -0,0 +1,185 @@
+import { Analysis, Entity, File, Scenario } from '~codeyam/types';
+
+/**
+ * Generates a standalone Node.js script that executes a library function or class method
+ * and captures execution results (return value, errors, console output, side effects).
+ *
+ * This is used instead of the React wrapper + Playwright approach for library functions.
+ *
+ * Supports:
+ * - Regular library functions
+ * - Static class methods (called directly on the class)
+ * - Instance class methods (creates instance first, then calls method)
+ */
+export default function directExecutionScript(
+  file: File,
+  entity: Entity,
+  analysis: Analysis,
+  scenario: Scenario,
+): string {
+  const { name: entityName } = entity;
+
+  // notExported entities cannot be imported, so we can't generate an execution script
+  if (entity.metadata?.notExported) {
+    console.log(
+      'CodeYam Error: directExecutionScript called with notExported entity',
+      {
+        entityName,
+        filePath: file.path,
+        metadata: entity.metadata,
+      },
+    );
+    throw new Error(
+      `Cannot generate execution script for entity '${entityName}' - it is not exported from '${file.path}'`,
+    );
+  }
+
+  const safeEntityName =
+    entityName === 'default' ? 'defaultExport' : entityName;
+
+  // Check if this is a class method
+  const isMethod = entity.entityType === 'method';
+  const isStaticMethod = isMethod && entity.metadata?.isStatic;
+  const isInstanceMethod = isMethod && !entity.metadata?.isStatic;
+  const parentClass = entity.metadata?.parentClass;
+  const methodName = entity.metadata?.methodName;
+
+  // Get the arguments from scenario data
+  const argumentsData = scenario.metadata?.data?.argumentsData || [];
+  const argumentsJson = JSON.stringify(argumentsData, null, 2);
+
+  // For instance methods, get constructor arguments from mockData
+  const mockData = scenario.metadata?.data?.mockData || {};
+  const constructorKey = isInstanceMethod ? `${parentClass}.constructor` : null;
+  const constructorArgs = constructorKey ? mockData[constructorKey] || [] : [];
+  const constructorArgsJson = JSON.stringify(constructorArgs, null, 2);
+
+  // Build import path - relative from .codeyam-execution/ directory to project root
+  // Script is at: ../project/.codeyam-execution/script.mjs
+  // File is at: ../project/codeyam-cli/src/webserver/app/lib/file.ts
+  // Relative path from script: ../${file.path}
+  const importPath = file.path.replace(/\.(ts|tsx|js|jsx)$/, '');
+
+  // Determine if it's a named or default export
+  const isDefaultExport = entity.name === 'default';
+  const isNamedExport = entity.metadata?.namedExport;
+
+  let importStatement: string;
+  if (isMethod) {
+    // For methods, we always import the parent class
+    importStatement = `import { ${parentClass} } from '../${importPath}';`;
+  } else if (isDefaultExport) {
+    importStatement = `import defaultExport from '../${importPath}';`;
+  } else if (isNamedExport) {
+    importStatement = `import { ${entityName} } from '../${importPath}';`;
+  } else {
+    importStatement = `import ${entityName} from '../${importPath}';`;
+  }
+
+  return `
+// CodeYam Direct Execution Script
+// Analysis: ${analysis.id}
+// Entity: ${entityName}
+// Scenario: ${scenario.name}
+// File: ${file.path}
+
+${importStatement}
+
+// Execution result structure
+const executionResult = {
+  returnValue: undefined,
+  error: null,
+  sideEffects: {
+    consoleOutput: [],
+    fileWrites: [],
+    apiCalls: [],
+  },
+  timing: {
+    duration: 0,
+    timestamp: new Date().toISOString(),
+  },
+};
+
+// Intercept console methods
+const originalConsole = {
+  log: console.log,
+  error: console.error,
+  warn: console.warn,
+  info: console.info,
+  debug: console.debug,
+};
+
+const interceptConsole = () => {
+  ['log', 'error', 'warn', 'info', 'debug'].forEach((level) => {
+    console[level] = (...args) => {
+      executionResult.sideEffects.consoleOutput.push({
+        level,
+        args: args.map(arg => {
+          // Safely stringify objects
+          if (typeof arg === 'object' && arg !== null) {
+            try {
+              return JSON.stringify(arg);
+            } catch (e) {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        }),
+      });
+      originalConsole[level](...args);
+    };
+  });
+};
+
+const restoreConsole = () => {
+  Object.assign(console, originalConsole);
+};
+
+// Main execution
+async function execute() {
+  const args = ${argumentsJson};
+  ${isInstanceMethod ? `const constructorArgs = ${constructorArgsJson};` : ''}
+
+  interceptConsole();
+
+  const startTime = Date.now();
+
+  try {
+    let result;
+
+    ${
+      isStaticMethod
+        ? `// Static method - call directly on class
+    result = await ${parentClass}.${methodName}(...args);`
+        : isInstanceMethod
+          ? `// Instance method - create instance with constructor args, then call method
+    const instance = new ${parentClass}(...constructorArgs);
+    result = await instance.${methodName}(...args);`
+          : `// Regular function - call directly
+    result = await ${safeEntityName}(...args);`
+    }
+
+    executionResult.returnValue = result;
+  } catch (error) {
+    executionResult.error = {
+      message: error.message,
+      stack: error.stack,
+      name: error.name,
+    };
+  } finally {
+    restoreConsole();
+    executionResult.timing.duration = Date.now() - startTime;
+  }
+
+  // Output results as JSON for parent process to capture
+  console.log('__CODEYAM_EXECUTION_RESULT__');
+  console.log(JSON.stringify(executionResult, null, 2));
+  console.log('__CODEYAM_EXECUTION_END__');
+}
+
+execute().catch((error) => {
+  console.error('Fatal error during execution:', error);
+  process.exit(1);
+});
+`;
+}

package/analyzer-template/packages/generate/src/lib/escapeQuotes.ts

@@ -0,0 +1,3 @@
+export default function escapeQuotes(s: string | null | undefined): string {
+  return s ? s.replace(/"/g, '"').replace(/'/g, ''') : '';
+}

package/analyzer-template/packages/generate/src/lib/getComponentImportStatement.ts

@@ -0,0 +1,60 @@
+import { Analysis, Entity, File, Scenario } from '~codeyam/types';
+import getComponentScenarioPath from './getComponentScenarioPath';
+import { safeFileName } from '~codeyam/utils';
+import requiredNodeModuleImports from './requiredNodeModuleImports';
+
+export interface GetComponentImportStatementsArgs {
+  file: File;
+  entity: Entity;
+  analysis: Analysis;
+  currentPath: string;
+  appPath: string;
+  scenario?: Scenario;
+  primary?: boolean;
+  namedExport?: boolean;
+}
+
+export default function getComponentImportStatement({
+  file,
+  entity,
+  analysis,
+  currentPath,
+  appPath,
+  scenario,
+  primary,
+  namedExport,
+}: GetComponentImportStatementsArgs) {
+  const importStatements: string[] = [];
+
+  let entityName =
+    primary && entity.entityType === 'library'
+      ? safeFileName(entity.name)
+      : entity.name;
+
+  const componentScenarioPath = getComponentScenarioPath(
+    file,
+    entity,
+    currentPath,
+    appPath,
+    scenario,
+    primary,
+  );
+
+  if (namedExport) {
+    importStatements.push(
+      `import { ${entityName} } from "${componentScenarioPath}";`,
+    );
+  } else {
+    if (entityName === 'default') {
+      entityName =
+        entity.entityType === 'library' ? 'defaultExport' : 'DefaultExport';
+    }
+    importStatements.push(
+      `import ${entityName} from "${componentScenarioPath}";`,
+    );
+  }
+
+  importStatements.push(...requiredNodeModuleImports(analysis));
+
+  return importStatements.join('\n');
+}

package/analyzer-template/packages/generate/src/lib/getComponentImportStatements.ts

@@ -0,0 +1,38 @@
+import { Scenario, ProjectFramework } from '~codeyam/types';
+import { safeFileName } from '~codeyam/utils';
+
+interface GetComponentImportStatementsArgs {
+  fileName: string;
+  filePath: string;
+  scenarios: Scenario[];
+  framework: ProjectFramework;
+}
+
+export default function getComponentImportStatements({
+  fileName,
+  filePath,
+  scenarios,
+}: GetComponentImportStatementsArgs) {
+  const componentName = fileName.split('.')[0];
+  const pathParts = filePath.split('/').slice(0, -1);
+  const relativePathStartIndex = pathParts.indexOf('app') + 1;
+  const relativePath = pathParts.slice(relativePathStartIndex).join('/');
+
+  const importStatements: string[] = [];
+
+  if (scenarios && scenarios.length > 0) {
+    scenarios.forEach((scenario) => {
+      const scenarioSlug = safeFileName(scenario.name);
+      const componentNameSafe = `${componentName}_${scenarioSlug}`;
+      const importPath = `${relativePath}/${scenarioSlug}_${componentName}`;
+      const importStatement = `import ${componentNameSafe} from "${importPath}";`;
+      importStatements.push(importStatement);
+    });
+  } else {
+    // If no examples had mocks, add the default import statement
+    const defaultImportStatement = `import ${componentName} from "${relativePath}/${componentName}";`;
+    importStatements.push(defaultImportStatement);
+  }
+
+  return importStatements.join('\n');
+}

package/analyzer-template/packages/generate/src/lib/getComponentScenarioPath.ts

@@ -0,0 +1,40 @@
+import { Entity, File, Scenario } from '~codeyam/types';
+import { safeFileName } from '~codeyam/utils';
+import getRelativePath from './getRelativePath';
+import safeFolder from './safeFolder';
+
+export const CODEYAM_DEMO_PAGES_DIRNAME = '__codeyamDemoPages__';
+
+export default function getComponentScenarioPath(
+  file: File,
+  entity: Entity,
+  currentPath: string,
+  appPath: string,
+  scenario: Scenario,
+  primary: boolean,
+) {
+  const { name: entityName } = entity;
+  const isLibraryDemoPage = entity.entityType === 'library' && primary;
+  const filePath = isLibraryDemoPage
+    ? `${appPath}/${CODEYAM_DEMO_PAGES_DIRNAME}/${file.name}`
+    : file.path;
+
+  const relativePath = safeFolder(
+    getRelativePath(currentPath, filePath).split('/').slice(0, -1).join('/'),
+  );
+
+  // Check if the file is an index file (e.g., index.tsx, index.ts)
+  // This must match the logic in writeScenarioComponents.ts
+  const isIndexFile = file.name.startsWith('index.');
+  const indexPrefix = isIndexFile ? 'index_' : '';
+
+  if (scenario) {
+    // Include scenario name in path to allow multiple scenarios to coexist
+    const importPath = isLibraryDemoPage
+      ? `${relativePath}/${entity.sha}_${indexPrefix}${safeFileName(entityName)}_${safeFileName(scenario.name)}`
+      : `${relativePath}/${entity.sha}_${indexPrefix}${safeFileName(entityName)}_${safeFileName(scenario.name)}`;
+    return `${importPath}`;
+  }
+
+  return `${relativePath}_${entity.sha}_${indexPrefix}${safeFileName(entityName)}`;
+}

package/analyzer-template/packages/generate/src/lib/getRelativePath.ts

@@ -0,0 +1,42 @@
+import { PROJECT_RELATIVE_PATH } from '~codeyam/utils';
+
+function normalizeToProjectRoot(pathString: string) {
+  const projectPrefix = PROJECT_RELATIVE_PATH + '/'; // '../project/'
+
+  if (pathString.startsWith(projectPrefix)) {
+    return pathString.slice(projectPrefix.length);
+  }
+
+  return pathString; // Return unchanged if no project prefix
+}
+
+export default function getRelativePath(filePath: string, importPath: string) {
+  // Normalize both paths to project root reference
+  const normalizedFilePath = normalizeToProjectRoot(filePath);
+  const normalizedImportPath = normalizeToProjectRoot(importPath);
+
+  const filePathParts = normalizedFilePath.split('/');
+  const importPathParts = normalizedImportPath.split('/');
+
+  const filePathFolders = filePathParts.slice(0, -1);
+  const importPathFolders = importPathParts.slice(0, -1);
+
+  let i = 0;
+  while (i < filePathFolders.length && i < importPathFolders.length) {
+    if (filePathFolders[i] !== importPathFolders[i]) {
+      break;
+    }
+    i++;
+  }
+
+  const backSteps = filePathFolders.slice(i);
+  const forwardSteps = importPathParts.slice(i);
+
+  const relativePath = backSteps.map(() => '..').concat(forwardSteps);
+
+  if (relativePath[0] !== '..') {
+    relativePath.splice(0, 0, '.');
+  }
+
+  return relativePath.join('/').replace(/\/$/, '');
+}

package/analyzer-template/packages/generate/src/lib/handleCmdk.ts

@@ -0,0 +1,61 @@
+import { createAliases } from './handleRadix';
+
+/**
+ * Minimal wrapper map for the ⌘ k / cmdk primitives.
+ *
+ * – Keys are cmdk component names (dot notation).
+ * – Values are functions that receive the raw JSX snippet (children)
+ *   and return a string wrapped in the fewest providers necessary
+ *   to avoid context/runtime errors such as
+ *   “Cannot read properties of undefined (reading 'subscribe')”.
+ *
+ * The rules are:
+ *   • Anything that lives under <Command.List> must get a Root + List.
+ *   • Everything else just needs a Root (or Dialog for the modal variant).
+ *
+ * Sources:
+ *   • Official examples that show the required nesting order :contentReference[oaicite:0]{index=0}
+ *   • GitHub issue confirming the missing-provider error :contentReference[oaicite:1]{index=1}
+ */
+const baseCmdkWrapperMap: Record<string, (c: string) => string> = {
+  // ── Core ──────────────────────────────────────────────
+  'Command.Input': (c) => `<CYCommand>${c}</CYCommand>`,
+  'Command.List': (c) => `<CYCommand>${c}</CYCommand>`,
+
+  // ── List-level sub-parts ──────────────────────────────
+  'Command.Item': (c) =>
+    `<CYCommand><CYCommand.List>${c}</CYCommand.List></CYCommand>`,
+  'Command.Group': (c) =>
+    `<CYCommand><CYCommand.List>${c}</CYCommand.List></CYCommand>`,
+  'Command.Separator': (c) =>
+    `<CYCommand><CYCommand.List>${c}</CYCommand.List></CYCommand>`,
+  'Command.Empty': (c) =>
+    `<CYCommand><CYCommand.List>${c}</CYCommand.List></CYCommand>`,
+  'Command.Loading': (c) =>
+    `<CYCommand><CYCommand.List>${c}</CYCommand.List></CYCommand>`,
+
+  // Needs a dummy item so <Shortcut> finds its parent context
+  'Command.Shortcut': (c) =>
+    `<CYCommand><CYCommand.List><CYCommand.Item value="x">${c}</CYCommand.Item></CYCommand.List></CYCommand>`,
+
+  // ── Dialog variant ────────────────────────────────────
+  'Command.Dialog': (c) => `<CYCommand.Dialog open>${c}</CYCommand.Dialog>`,
+};
+
+// Re-use your alias helper so <CommandItem> works too.
+const cmdkWrapperMap = createAliases(baseCmdkWrapperMap);
+
+/**
+ * Wraps a cmdk primitive snippet with the providers it needs.
+ *
+ * @param componentContent JSX string of a *single* cmdk element.
+ * @returns Wrapped JSX if we know the component, otherwise unchanged.
+ */
+export function handleCmdk(componentContent: string): string {
+  const match = componentContent.match(/< *([A-Z][A-Za-z0-9\.]*)/);
+  if (!match?.[1]) return componentContent;
+
+  const name = match[1];
+  const wrapper = cmdkWrapperMap[name];
+  return wrapper ? wrapper(componentContent) : componentContent;
+}