@codeyam/codeyam-cli 0.1.0-staging.15d0f46 → 0.1.0-staging.1669d45

package/analyzer-template/project/controller/startController.ts

@@ -13,8 +13,8 @@ export enum ControllerPhase {
   Startup = 'STARTUP',
   RepoCheckout = 'REPO_CHECKOUT',
   Analysis = 'ANALYSIS',
+  AnalysisProducing = 'ANALYSIS_PRODUCING',
   Serving = 'SERVING',
-  Orchestrating = 'ORCHESTRATING',
   Complete = 'COMPLETE',
 }
 
@@ -30,6 +30,7 @@ type ControllerContext =
   | { phase: ControllerPhase.Startup; info: null }
   | { phase: ControllerPhase.RepoCheckout; info: null }
   | { phase: ControllerPhase.Analysis; info: null }
+  | { phase: ControllerPhase.AnalysisProducing; info: null }
   | { phase: ControllerPhase.Serving; info: ServingCodeYamInfo }
   | { phase: ControllerPhase.Complete; info: null };
 
@@ -100,6 +101,11 @@ export class Controller extends EventEmitter {
     this.setPhase({ phase: ControllerPhase.Analysis, info: null });
   }
 
+  setAnalysisProducingPhase(): void {
+    this.setPhase({ phase: ControllerPhase.AnalysisProducing, info: null });
+    this.emit('analysisProducing');
+  }
+
   setServingPhase(info: ServingCodeYamInfo): void {
     this.setPhase({ phase: ControllerPhase.Serving, info });
   }
@@ -116,6 +122,15 @@ export class Controller extends EventEmitter {
     );
   }
 
+  hasStartedProducing(): boolean {
+    // Analysis is producing once we've moved past the Analysis phase
+    return (
+      this.context.phase === ControllerPhase.AnalysisProducing ||
+      this.context.phase === ControllerPhase.Serving ||
+      this.context.phase === ControllerPhase.Complete
+    );
+  }
+
   async close(): Promise<void> {
     if (!this.server) return;
 

package/analyzer-template/project/executeLibraryFunctionDirect.ts

@@ -33,11 +33,15 @@ export default async function executeLibraryFunctionDirect(
   // Generate the execution script
   const script = directExecutionScript(file, entity, analysis, scenario);
 
+  // Use .ts extension for TypeScript source files so tsx can resolve TS imports
+  const isTypeScript = file.path.endsWith('.ts') || file.path.endsWith('.tsx');
+  const scriptExtension = isTypeScript ? '.ts' : '.mjs';
+
   // Write the script to a temporary file
   const scriptPath = path.join(
     PROJECT_RELATIVE_PATH,
     '.codeyam-execution',
-    `${entity.sha}_${scenario.id}.mjs`,
+    `${entity.sha}_${scenario.id}${scriptExtension}`,
   );
 
   await writeFile(scriptPath, script);
@@ -54,10 +58,10 @@ export default async function executeLibraryFunctionDirect(
       command: 'npx',
       args: ['tsx', scriptPath],
       workingDir: PROJECT_RELATIVE_PATH,
-      onData: async (data) => {
+      onData: (data) => {
         stdout += data;
       },
-      onError: async (data) => {
+      onError: (data) => {
         stderr += data;
       },
       processName: 'library-function-execution',

package/analyzer-template/project/mocks/analyzeFileMock.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/require-await */
 import {
   Analysis,
   AnalysisMap,
@@ -47,7 +48,7 @@ const standaloneComponentAnalysis = {
         'The counter is initialized at 0, with the ability to increment and decrement the count.',
       metadata: {
         dataMapping: {},
-        keyAttributeInstructions: {},
+        coveredFlows: [],
         data: {
           argumentsData: [],
           mockData: {},
@@ -221,7 +222,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -242,7 +243,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -263,7 +264,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is 40 years or older and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -284,7 +285,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -305,7 +306,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -378,7 +379,7 @@ async function analyzeReturnsImportedComponentsFile(): Promise<{
               description: 'Default scenario description',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [],
                   mockData: {},

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -46,13 +46,10 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             'status',
           ])
           // Base condition: readyToBeCaptured = true
-          // Use json_extract for SQLite (returns 1 for boolean true)
+          // Use -> operator which works in both PostgreSQL and SQLite
+          // Both return a value that compares equal to string 'true'
           .where((eb) =>
-            eb(
-              sql`json_extract(${sql.ref('status')}, '$.readyToBeCaptured')`,
-              '=',
-              sql`1`,
-            ),
+            eb(sql`${sql.ref('status')} -> 'readyToBeCaptured'`, '=', 'true'),
           )
           // Project filter (always required)
           .where('project_id', '=', this.config.project.id);

package/analyzer-template/project/orchestrateCapture/SequentialCaptureTaskRunner.ts

@@ -91,47 +91,59 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Derive paths
     const parentDir = parentOfCodeyam;
-    const capturerPath = path.normalize(path.join(parentDir, 'capturer-1'));
 
-    console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
-
-    // Create capturer base directory
-    if (!fs.existsSync(capturerPath)) {
-      fs.mkdirSync(capturerPath, { recursive: true });
-    }
+    // In CAPTURE_ONLY mode, run directly from the main project folder (skip rsync)
+    // This preserves any manual edits made to generated files
+    const captureOnly = process.env.CAPTURE_ONLY === 'true';
+    const capturerPath = captureOnly
+      ? parentDir
+      : path.normalize(path.join(parentDir, 'capturer-1'));
 
-    // Copy both codeyam/ and project/ into capturer-1/
-    // start.ts waits for repo checkout to complete before creating this runner
-    console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
-    await rsyncCopy({
-      sourcePath: parentDir,
-      destinationPath: capturerPath,
-      excludes: ['codeyam/log.txt', 'capturer-*'],
-      silent: false,
-    });
+    console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
 
-    // Sanitize env files in capturer project (replaces real values with mock placeholders)
-    const capturerProjectPath = path.join(capturerPath, 'project');
-    console.log('CodeYam: Sanitizing env files in capturer project...');
-    const sanitizeResult = sanitizeEnvFiles({
-      projectPath: capturerProjectPath,
-      log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
-    });
-    if (sanitizeResult.sanitizedFiles.length > 0) {
+    if (captureOnly) {
       console.log(
-        `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        'CodeYam: CAPTURE_ONLY mode - running from main project folder, skipping rsync',
       );
-    }
+    } else {
+      // Create capturer base directory
+      if (!fs.existsSync(capturerPath)) {
+        fs.mkdirSync(capturerPath, { recursive: true });
+      }
 
-    // Apply universal mocks to capturer project
-    if (context.universalMocks && context.universalMocks.length > 0) {
-      console.log(
-        `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
-      );
-      await applyUniversalMocks({
-        mocks: context.universalMocks,
+      // Copy both codeyam/ and project/ into capturer-1/
+      // start.ts waits for repo checkout to complete before creating this runner
+      console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
+      await rsyncCopy({
+        sourcePath: parentDir,
+        destinationPath: capturerPath,
+        excludes: ['codeyam/log.txt', 'capturer-*'],
+        silent: false,
+      });
+
+      // Sanitize env files in capturer project (replaces real values with mock placeholders)
+      const capturerProjectPath = path.join(capturerPath, 'project');
+      console.log('CodeYam: Sanitizing env files in capturer project...');
+      const sanitizeResult = sanitizeEnvFiles({
         projectPath: capturerProjectPath,
+        log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
       });
+      if (sanitizeResult.sanitizedFiles.length > 0) {
+        console.log(
+          `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        );
+      }
+
+      // Apply universal mocks to capturer project
+      if (context.universalMocks && context.universalMocks.length > 0) {
+        console.log(
+          `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
+        );
+        await applyUniversalMocks({
+          mocks: context.universalMocks,
+          projectPath: capturerProjectPath,
+        });
+      }
     }
 
     const runner = new SequentialCaptureTaskRunner(
@@ -247,6 +259,10 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         READY_TO_BE_CAPTURED: 'true',
         PROJECT_SLUG: this.config.projectSlug,
         CODEYAM_LOG_PATH: capturerLogPath,
+        // Pass CAPTURE_ONLY through from parent process to skip file regeneration
+        ...(process.env.CAPTURE_ONLY && {
+          CAPTURE_ONLY: process.env.CAPTURE_ONLY,
+        }),
       },
       workingDir: capturerCodeyamPath,
       processName: 'project',

package/analyzer-template/project/orchestrateCapture.ts

@@ -50,6 +50,9 @@ interface OrchestrateCaptureArgs {
   taskRunner: CaptureTaskRunner;
   analysisLoader?: AnalysisLoader;
   pollingInterval?: number;
+  // Optional commit for metadata/progress tracking only (not filtering).
+  // Use when full=true but you still want capture progress updates on a commit.
+  metadataCommit?: Commit | null;
 }
 
 export default async function orchestrateCapture({
@@ -62,6 +65,7 @@ export default async function orchestrateCapture({
   taskRunner,
   analysisLoader,
   pollingInterval = POLLING_INTERVAL,
+  metadataCommit,
 }: OrchestrateCaptureArgs) {
   if (!full && !analysisIds && !commit && !entityShas) {
     throw new Error(
@@ -318,9 +322,12 @@ export default async function orchestrateCapture({
         // console.log(
         //   `Codeyam Debug: All known analyses: ${Array.from(knownAnalyses).join(', ')}`,
         // );
-        if (commit) {
-          commit.metadata = await updateCommitMetadata({
-            commitId: commit.id,
+        // Use metadataCommit if provided, otherwise fall back to commit.
+        // This allows progress tracking even when commit is null (e.g., full=true mode).
+        const trackingCommit = metadataCommit ?? commit;
+        if (trackingCommit) {
+          trackingCommit.metadata = await updateCommitMetadata({
+            commitId: trackingCommit.id,
             runStatusUpdate: {
               readyToBeCaptured: knownAnalyses.size,
               capturesAttempted: capturedAnalysisIds.length + abandoned.length,

package/analyzer-template/project/reconcileMockDataKeys.ts

@@ -5,7 +5,10 @@
  * (e.g., "eq('user_id', 'user-12345')") when the mock code expects variable
  * references (e.g., "eq('user_id', user.id)").
  *
- * This function remaps mismatched keys to their expected equivalents.
+ * Keys are now original call signatures (e.g., "useFetcher<User>()", "db.select(query)").
+ *
+ * @param mockData The mock data object to reconcile
+ * @param expectedKeys The expected keys from the structure
  */
 export function reconcileMockDataKeys(
   mockData: Record<string, unknown>,
@@ -26,7 +29,7 @@ export function reconcileMockDataKeys(
       continue;
     }
 
-    // Try to find closest match
+    // Try to find closest match using existing logic
     const closestKey = findClosestKey(key, expectedKeys);
     if (closestKey) {
       result[closestKey] = reconciledValue;
@@ -47,9 +50,15 @@ export function reconcileMockDataKeys(
  * - Ignore the last argument value (could be literal or variable)
  * - Match based on the common prefix
  * - If key has no parentheses, try matching with "()" appended
+ * - If key is "funcName()" (empty args), match expected key "funcName({...})" by function name
+ * - If key has object arguments (like useQuery({...})), match by function name
+ * - If key has single argument with literal value, match by function name
  *
  * e.g., "eq('user_id', 'user-12345')" matches "eq('user_id', user.id)"
  * e.g., "getAll" matches "getAll()"
+ * e.g., "getSurveysAction()" matches "getSurveysAction({ environmentId, ... })"
+ * e.g., "useQuery({ id: 123 })" matches "useQuery({ id: Number(id) })"
+ * e.g., "useCustomSizes('example-slug')" matches "useCustomSizes(projectSlug)"
  */
 function findClosestKey(key: string, expectedKeys: string[]): string | null {
   const keyBase = extractKeyBase(key);
@@ -73,9 +82,100 @@ function findClosestKey(key: string, expectedKeys: string[]): string | null {
     }
   }
 
+  // If key is "funcName()" (empty args), try matching expected key "funcName({...})"
+  // This handles the case where LLM generates "getSurveysAction()" but expected key
+  // is "getSurveysAction({ environmentId, limit, ... })" with an object argument
+  const emptyArgsMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/);
+  if (emptyArgsMatch) {
+    const funcName = emptyArgsMatch[1];
+    for (const expected of expectedKeys) {
+      // Match if expected key starts with the same function name and has args
+      const expectedMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcName)}\\([^)]+\\)$`),
+      );
+      if (expectedMatch) {
+        return expected;
+      }
+    }
+  }
+
+  // If key has object literal arguments (like "useQuery({ id: 123, ... })"),
+  // try matching expected keys with the same function name and object arguments.
+  // This handles cases where LLM generates literal values but expected keys have variable references.
+  // e.g., "useQuery({ id: 123 })" matches "useQuery({ id: Number(id) })"
+  // e.g., "trpc.users.getById.useQuery({ userId: 'user-123' })" matches "trpc.users.getById.useQuery({ userId })"
+  const objectArgMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(\s*\{/);
+  if (objectArgMatch) {
+    const funcPath = objectArgMatch[1]; // Can be "funcName" or "path.to.funcName"
+    for (const expected of expectedKeys) {
+      // Match if expected key has the same function path and starts with object argument
+      const expectedObjArgMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcPath)}\\s*\\(\\s*\\{`),
+      );
+      if (expectedObjArgMatch) {
+        return expected;
+      }
+    }
+  }
+
+  // If key has a single argument with a literal value (string, number, etc.),
+  // try matching expected keys with the same function name but different argument.
+  // This handles cases where LLM generates "useCustomSizes('example-slug')" but expected
+  // key is "useCustomSizes(projectSlug)" with a variable reference.
+  // e.g., "useCustomSizes('example-slug')" matches "useCustomSizes(projectSlug)"
+  const singleArgMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(([^,)]+)\)$/,
+  );
+  if (singleArgMatch) {
+    const funcPath = singleArgMatch[1];
+    const arg = singleArgMatch[2].trim();
+    // Only apply this matching if the argument looks like a literal (quoted string or number)
+    const isLiteralArg = /^['"`].*['"`]$/.test(arg) || /^\d+$/.test(arg);
+    if (isLiteralArg) {
+      for (const expected of expectedKeys) {
+        // Match if expected key has the same function path with a single argument
+        const expectedSingleArgMatch = expected.match(
+          new RegExp(`^${escapeRegExp(funcPath)}\\s*\\([^,)]+\\)$`),
+        );
+        if (expectedSingleArgMatch) {
+          return expected;
+        }
+      }
+    }
+  }
+
+  // If key has multiple arguments where one contains a literal value,
+  // try matching expected keys with the same function name and argument count.
+  // This handles cases like "getScenarioDisplayState(scenario, undefined, undefined, 'entitysha123', undefined)"
+  // matching "getScenarioDisplayState(scenario, undefined, undefined, entitySha, undefined)"
+  const multiArgWithLiteralMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\((.+)\)$/,
+  );
+  if (multiArgWithLiteralMatch) {
+    const funcPath = multiArgWithLiteralMatch[1];
+    const argsStr = multiArgWithLiteralMatch[2];
+    // Check if any argument is a string literal
+    const hasLiteralArg = /'[^']*'|"[^"]*"/.test(argsStr);
+    if (hasLiteralArg) {
+      for (const expected of expectedKeys) {
+        // Match if expected key starts with the same function path
+        if (expected.startsWith(funcPath + '(')) {
+          return expected;
+        }
+      }
+    }
+  }
+
   return null;
 }
 
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 /**
  * Normalize quotes in a string: convert double quotes to single quotes.
  * This handles cases where the LLM generates keys with double quotes

package/analyzer-template/project/runAnalysis.ts

@@ -215,6 +215,11 @@ export default async function runAnalysis({
       entityShas,
       branchName: branch?.name,
     });
+
+    // Propagate the fallback branch to branchCommit so downstream code can use it
+    if (branchCommit && branch) {
+      branchCommit.branch = branch;
+    }
   }
 
   // After this block, 'commit' is the union of a regular or baseline commit
@@ -330,6 +335,7 @@ export default async function runAnalysis({
         desiredAnalyses,
         force,
         fileStore,
+        onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
       });
     }
 
@@ -350,6 +356,7 @@ export default async function runAnalysis({
       backgroundJob,
       desiredAnalyses,
       fileStore,
+      onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
     });
   } catch (e) {
     awsLog('CodeYam Error: Analysis failed', {

package/analyzer-template/project/serverOnlyModules.ts

@@ -213,6 +213,108 @@ export function applyServerOnlyMocks(fileContent: string): string {
   return applyServerOnlyMocksAst(fileContent);
 }
 
+/**
+ * Check if a file exports an "env" variable that's derived from a node module import.
+ * This is a generic pattern for env configuration packages (like @t3-oss/env-*, envalid, etc.)
+ * that create server-only environment objects.
+ *
+ * Pattern detected:
+ *   import { someFunc } from "some-package";
+ *   export const env = someFunc({...});
+ *
+ * Returns the name of the imported function if detected, null otherwise.
+ */
+function detectEnvStoreFromNodeModule(sourceFile: ts.SourceFile): {
+  importedFunctionName: string;
+  modulePath: string;
+} | null {
+  // First, collect all imported function names from node modules
+  const nodeModuleImports = new Map<string, string>(); // functionName -> modulePath
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) continue;
+
+    const moduleSpecifier = statement.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier)) continue;
+
+    const modulePath = moduleSpecifier.text;
+    // Skip relative imports - only look at node modules
+    if (modulePath.startsWith('.') || modulePath.startsWith('/')) continue;
+
+    if (
+      statement.importClause?.namedBindings &&
+      ts.isNamedImports(statement.importClause.namedBindings)
+    ) {
+      for (const element of statement.importClause.namedBindings.elements) {
+        nodeModuleImports.set(element.name.text, modulePath);
+      }
+    }
+    if (statement.importClause?.name) {
+      nodeModuleImports.set(statement.importClause.name.text, modulePath);
+    }
+  }
+
+  // Now look for: export const env = importedFunc(...)
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+
+    // Check if it's exported
+    const isExported = statement.modifiers?.some(
+      (m) => m.kind === ts.SyntaxKind.ExportKeyword,
+    );
+    if (!isExported) continue;
+
+    for (const decl of statement.declarationList.declarations) {
+      // Check if variable is named "env"
+      if (!ts.isIdentifier(decl.name) || decl.name.text !== 'env') continue;
+
+      // Check if initializer is a call expression
+      if (!decl.initializer || !ts.isCallExpression(decl.initializer)) continue;
+
+      // Get the function being called
+      const callExpr = decl.initializer.expression;
+      let funcName: string | null = null;
+
+      if (ts.isIdentifier(callExpr)) {
+        funcName = callExpr.text;
+      } else if (
+        ts.isPropertyAccessExpression(callExpr) &&
+        ts.isIdentifier(callExpr.name)
+      ) {
+        funcName = callExpr.name.text;
+      }
+
+      if (funcName && nodeModuleImports.has(funcName)) {
+        return {
+          importedFunctionName: funcName,
+          modulePath: nodeModuleImports.get(funcName)!,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Generate mock code for env store patterns.
+ * Replaces the imported function with one that returns a proxy.
+ */
+function generateEnvStoreMock(functionName: string): string {
+  return `// Mock for env store function (server-only env vars)
+const ${functionName} = (config: any) => {
+  // Return a proxy that returns undefined for any property access
+  // This allows the code to run on the client without throwing
+  return new Proxy({} as any, {
+    get: (target, prop) => {
+      if (prop === 'then' || prop === Symbol.toStringTag) return undefined;
+      return undefined;
+    },
+  });
+};
+`;
+}
+
 /**
  * AST-based implementation of applyServerOnlyMocks for large files.
  * Uses TypeScript parser instead of regex to avoid catastrophic backtracking.
@@ -229,6 +331,10 @@ function applyServerOnlyMocksAst(fileContent: string): string {
     const replacements: { start: number; end: number; replacement: string }[] =
       [];
 
+    // Check if this file exports an "env" variable from a node module function call
+    // This is a generic pattern for env configuration packages
+    const envStoreInfo = detectEnvStoreFromNodeModule(sourceFile);
+
     for (const statement of sourceFile.statements) {
       if (!ts.isImportDeclaration(statement)) continue;
 
@@ -236,8 +342,6 @@ function applyServerOnlyMocksAst(fileContent: string): string {
       if (!ts.isStringLiteral(moduleSpecifier)) continue;
 
       const modulePath = moduleSpecifier.text;
-      const config = findServerOnlyModule(modulePath);
-      if (!config) continue;
 
       // Extract import names
       const importNames: string[] = [];
@@ -265,6 +369,27 @@ function applyServerOnlyMocksAst(fileContent: string): string {
         }
       }
 
+      // Check if this import provides the function used to create the env store
+      if (
+        envStoreInfo &&
+        modulePath === envStoreInfo.modulePath &&
+        importNames.includes(envStoreInfo.importedFunctionName)
+      ) {
+        const mockCode = generateEnvStoreMock(
+          envStoreInfo.importedFunctionName,
+        );
+        replacements.push({
+          start: statement.getStart(sourceFile),
+          end: statement.getEnd(),
+          replacement: mockCode,
+        });
+        continue;
+      }
+
+      // Check for known server-only modules (from explicit list)
+      const config = findServerOnlyModule(modulePath);
+      if (!config) continue;
+
       const mockCode = config.getMockCode(importNames, defaultImportName);
       replacements.push({
         start: statement.getStart(sourceFile),