@codeyam/codeyam-cli 0.1.21 → 0.1.22

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeInDependentDataStructure.ts

@@ -41,6 +41,19 @@ function getTypeParameter(functionName: string): string | null {
   return null;
 }
 
+/**
+ * Check if a schema path contains a Set/Map collection method call.
+ * Paths like `.has(articleId)`, `.delete(articleId)`, `.add(articleId)` represent
+ * membership checks on Sets/Maps, not meaningful data flow for schema generation.
+ * These create massive combinatorial explosions when every filter field (filterRatings,
+ * filterPublications, filterAuthors, etc.) × every method (has, delete, add) gets
+ * tracked as a separate equivalency.
+ */
+const COLLECTION_METHOD_PATTERN = /\.(?:has|delete|add|clear|get|set)\(/;
+function isCollectionMethodPath(path: string): boolean {
+  return COLLECTION_METHOD_PATTERN.test(path);
+}
+
 // Primitive types that should not have child paths
 const PRIMITIVE_TYPES = new Set([
   'number',
@@ -142,12 +155,26 @@ function bestValueFromOptions(options: Array<string | undefined>) {
   return options[0] ?? 'unknown';
 }
 
+/** Timeout (ms) for the merge operation. Throws DataStructureTimeoutError if exceeded.
+ *  All successful merges complete in <300ms. Anything exceeding 2s is pathological. */
+const MERGE_TIMEOUT_MS = 2_000;
+
+export class DataStructureTimeoutError extends Error {
+  constructor(entityName: string, elapsedMs: number) {
+    super(
+      `Data structure merge timed out for ${entityName} after ${Math.round(elapsedMs / 1000)}s (limit: ${MERGE_TIMEOUT_MS / 1000}s)`,
+    );
+    this.name = 'DataStructureTimeoutError';
+  }
+}
+
 export default function mergeInDependentDataStructure({
   importedExports,
   dependentAnalyses,
   rootScopeName,
   dataStructure,
   dependencySchemas,
+  timeoutMs = MERGE_TIMEOUT_MS,
 }: {
   importedExports: Pick<
     Entity['metadata']['importedExports'][0],
@@ -169,7 +196,23 @@ export default function mergeInDependentDataStructure({
       [name: string]: DataStructureInfo;
     };
   };
+  /** Override the default timeout (ms). Set to 0 to disable. */
+  timeoutMs?: number;
 }) {
+  const mergeStartTime = Date.now();
+  const mergeDeadline = timeoutMs > 0 ? mergeStartTime + timeoutMs : 0;
+
+  /** Call in hot loops. Throws DataStructureTimeoutError if deadline exceeded.
+   *  Date.now() is ~20ns — negligible vs the ms-scale string ops in each iteration. */
+  const checkDeadline = () => {
+    if (!mergeDeadline) return;
+    if (Date.now() > mergeDeadline) {
+      throw new DataStructureTimeoutError(
+        rootScopeName,
+        Date.now() - mergeStartTime,
+      );
+    }
+  };
   const mergedDataStructure: Omit<
     DataStructure,
     'equivalentSignatureVariables'
@@ -310,7 +353,17 @@ export default function mergeInDependentDataStructure({
     );
   };
 
+  // Cache translatePath results — the same path is often translated multiple times
+  // (once per equivalency entry that references it). Avoids redundant
+  // splitOutsideParenthesesAndArrays calls on long paths.
+  const translatePathCache = new Map<string, string>();
+
   const translatePath = (path: string, dependencyName: string) => {
+    const cacheKey = `${dependencyName}\0${path}`;
+    const cached = translatePathCache.get(cacheKey);
+    if (cached !== undefined) return cached;
+
+    let result = path;
     if (path.startsWith(dependencyName)) {
       const pathParts = splitOutsideParenthesesAndArrays(path);
       if (pathParts.length > 1) {
@@ -318,33 +371,26 @@ export default function mergeInDependentDataStructure({
           // Check if this function has multiple DIFFERENT type parameters.
           // If so, DON'T normalize to returnValue - keep the full path to avoid
           // merging different type-parameterized variants together.
-          // e.g., useFetcher<{ data: UserData }>().functionCallReturnValue.data
-          // should NOT be merged with useFetcher<{ data: ConfigData }>().functionCallReturnValue.data
           const baseName = cleanFunctionName(pathParts[0]);
-          if (functionsWithMultipleTypeParams.has(baseName)) {
-            return path; // Keep the original path with type parameters
+          if (!functionsWithMultipleTypeParams.has(baseName)) {
+            // functionCallReturnValue immediately follows - normalize to returnValue
+            result = joinParenthesesAndArrays([
+              'returnValue',
+              ...pathParts.slice(2),
+            ]);
           }
-          // functionCallReturnValue immediately follows - normalize to returnValue
-          // e.g., useAuth().functionCallReturnValue.user -> returnValue.user
-          return joinParenthesesAndArrays([
-            'returnValue',
-            ...pathParts.slice(2),
-          ]);
         } else if (
           pathParts[0].endsWith(')') &&
           pathParts[1].startsWith('signature[')
         ) {
-          // Hook-style with signature access (e.g., BranchChangesTab().signature[0]...)
-          // Strip the function name for signature equivalency matching
-          return joinParenthesesAndArrays(pathParts.slice(1));
+          // Hook-style with signature access
+          result = joinParenthesesAndArrays(pathParts.slice(1));
         }
-        // For all other cases (object-style APIs like getSupabase().auth and
-        // direct object references like supabase.from), preserve the path as-is.
-        // The prefix must be kept for proper schema lookups in constructMockCode
-        // and gatherDataForMocks.
       }
     }
-    return path;
+
+    translatePathCache.set(cacheKey, result);
+    return result;
   };
 
   const gatherAllEquivalentSchemaPaths = (
@@ -358,6 +404,7 @@ export default function mergeInDependentDataStructure({
       'signatureSchema' | 'returnValueSchema'
     >,
   ) => {
+    checkDeadline();
     if (!sourceAndUsageEquivalencies) return;
 
     // Pre-computed normalized schema index cache.
@@ -380,6 +427,7 @@ export default function mergeInDependentDataStructure({
       if (cached) return cached;
       const byFirstPart = new Map<string, NormalizedEntry[]>();
       for (const path in schema) {
+        checkDeadline();
         let parts = splitOutsideParenthesesAndArrays(path);
         if (parts[0].startsWith(functionName)) {
           const baseName = cleanFunctionName(parts[0]);
@@ -441,6 +489,7 @@ export default function mergeInDependentDataStructure({
       // Use espIndex Map for O(1) lookup instead of O(E) linear search.
       // Falls back to linear search only when Map hit has a signature index conflict.
       for (const pathInfo of allPaths) {
+        checkDeadline();
         if (equivalentSchemaPathsEntry) break;
         const candidate = espIndex.get(
           espIndexKey(pathInfo.path, pathInfo.functionName),
@@ -572,20 +621,43 @@ export default function mergeInDependentDataStructure({
     for (const equivalencies of allEquivalencies) {
       const schemaPathEntries = Object.entries(equivalencies);
       for (const [schemaPath, usages] of schemaPathEntries) {
+        checkDeadline();
+
+        // Skip equivalency entries whose source path is a Set/Map membership operation.
+        // Patterns like `.has(articleId)`, `.delete(articleId)`, `.add(articleId)` on
+        // Sets/Maps represent membership checks, not meaningful data flow for schema generation.
+        // In the Margo LibraryPage case, these account for 74% of all equivalency targets
+        // (19,444 of 26,340) and cause a combinatorial explosion in the merge.
+        if (isCollectionMethodPath(schemaPath)) continue;
+
         // First, check if the raw schemaPath starts with a function call to a dependency.
         // If so, use that dependency name for translation (so translatePath can strip the prefix).
         const extractedFuncName = extractFunctionNameFromPath(schemaPath);
         const effectiveFunctionName = extractedFuncName || functionName;
         const translatedPath = translatePath(schemaPath, effectiveFunctionName);
 
-        const allPaths: { path: string; functionName?: string }[] = [
+        const allPathsRaw: { path: string; functionName?: string }[] = [
           { path: translatedPath, functionName: effectiveFunctionName },
-          ...usages.map((u) => ({
-            path: translatePath(u.schemaPath, u.scopeNodeName),
-            functionName: u.scopeNodeName,
-          })),
+          ...usages
+            .filter((u) => !isCollectionMethodPath(u.schemaPath))
+            .map((u) => ({
+              path: translatePath(u.schemaPath, u.scopeNodeName),
+              functionName: u.scopeNodeName,
+            })),
         ].filter((pathInfo) => !pathInfo.path.includes('.map('));
 
+        // Deduplicate by translated path + function name.
+        // Multiple call variants (e.g., loadView(viewKey(null,null)) vs loadView(viewKey(newTag,newCol)))
+        // translate to the same path after stripping arguments. Processing duplicates
+        // creates O(n²) work in the schema matching loops below.
+        const seenPathKeys = new Set<string>();
+        const allPaths = allPathsRaw.filter((p) => {
+          const key = `${p.functionName ?? ''}::${p.path}`;
+          if (seenPathKeys.has(key)) return false;
+          seenPathKeys.add(key);
+          return true;
+        });
+
         // Fix 38: Derive base paths from property access paths.
         // When we have equivalent paths like:
         //   Parent: signature[0].scenarios[].name
@@ -617,6 +689,7 @@ export default function mergeInDependentDataStructure({
 
         // For each child path, find its equivalent parent path and derive bases
         for (const childPathInfo of childPaths) {
+          checkDeadline();
           const childParts = splitOutsideParenthesesAndArrays(
             childPathInfo.path,
           );
@@ -743,6 +816,7 @@ export default function mergeInDependentDataStructure({
           });
         }
         for (const equivalentRoot of entry.equivalentRoots) {
+          checkDeadline();
           const dataStructures =
             equivalentRoot.function &&
             equivalentRoot.function.name !== rootScopeName
@@ -803,6 +877,7 @@ export default function mergeInDependentDataStructure({
               path: schemaPath,
               parts: schemaPathParts,
             } of candidates) {
+              checkDeadline();
               if (schemaPathParts.length < pathParts.length) continue;
 
               // Check if all path parts match (allowing function call variants)
@@ -910,6 +985,7 @@ export default function mergeInDependentDataStructure({
       // where we want both X().functionCallReturnValue and Y().functionCallReturnValue as bases
       const allBasePaths = new Set<string>();
       for (const path of Object.keys(dataStructure.returnValueSchema)) {
+        checkDeadline();
         const parts = splitOutsideParenthesesAndArrays(path);
         // Find all positions of functionCallReturnValue and create base paths for each
         for (let i = 0; i < parts.length; i++) {
@@ -944,6 +1020,7 @@ export default function mergeInDependentDataStructure({
 
         const basePathParts = splitOutsideParenthesesAndArrays(basePath);
         for (const schemaPath in dataStructure.returnValueSchema) {
+          checkDeadline();
           const schemaPathParts = splitOutsideParenthesesAndArrays(schemaPath);
           if (schemaPathParts.length < basePathParts.length) continue;
 
@@ -984,6 +1061,7 @@ export default function mergeInDependentDataStructure({
     // We do this before the main merge to ensure the connection happens regardless
     // of processing order.
     for (const esp of equivalentSchemaPaths) {
+      checkDeadline();
       for (const root of esp.equivalentRoots) {
         if (root.schemaRootPath.endsWith('[]')) {
           // Find a matching parent entry with the base array path
@@ -1004,6 +1082,7 @@ export default function mergeInDependentDataStructure({
             for (const [postfixPath, postfixValue] of Object.entries(
               esp.equivalentPostfixes,
             )) {
+              checkDeadline();
               const transformedPostfix = joinParenthesesAndArrays(
                 ['[]', postfixPath].filter(Boolean),
               );
@@ -1093,6 +1172,7 @@ export default function mergeInDependentDataStructure({
     );
 
     for (const esp of sortedEquivalentSchemaPaths) {
+      checkDeadline();
       if (esp.equivalentRoots.length === 0) continue;
       let bestCandidateLength: number | undefined;
       let bestCandidate: (typeof equivalentSchemaPaths)[0] | undefined;
@@ -1174,6 +1254,7 @@ export default function mergeInDependentDataStructure({
   // dependencySchemas contains usage information (how dependencies are called),
   // not internal implementation, so we want this for mocked dependencies too
   for (const dependency of importedExports) {
+    checkDeadline();
     const dependentDataStructure =
       dependencySchemas?.[dependency.filePath]?.[dependency.name];
     if (!dependentDataStructure) continue;
@@ -1198,18 +1279,36 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  const gatherElapsed = Date.now() - mergeStartTime;
+
   equivalentSchemaPaths = mergeAllEquivalentSchemaPaths();
 
+  const mergeEspElapsed = Date.now() - mergeStartTime;
+
   // Collect schemas that need cleaning — batch the calls for the end instead of
   // calling cleanSchema inside the inner root loop (which was O(roots * schemaSize)).
   const schemasToClean = new Set<{ [key: string]: string }>();
 
   for (const esp of equivalentSchemaPaths) {
+    checkDeadline();
     // Pre-compute which postfixes have children to avoid O(n²) lookups in the inner loop.
     // A postfix "has children" if there are other postfixes that extend it.
     const postfixesWithChildren = new Set<string>();
     const postfixKeys = Object.keys(esp.equivalentPostfixes);
 
+    // Pre-parse ALL postfix paths once. These parsed parts are reused in:
+    // 1. The children detection loop below
+    // 2. The inner postfix application loop (lines that split postfixPath and equivalentRoot.postfix)
+    // This eliminates thousands of redundant splitOutsideParenthesesAndArrays calls.
+    const postfixPartsCache = new Map<string, string[]>();
+    for (const postfixPath of postfixKeys) {
+      if (!postfixPath) continue;
+      postfixPartsCache.set(
+        postfixPath,
+        splitOutsideParenthesesAndArrays(postfixPath),
+      );
+    }
+
     // Check for empty postfix having children (any other postfixes exist)
     if (postfixKeys.length > 1 && '' in esp.equivalentPostfixes) {
       postfixesWithChildren.add('');
@@ -1221,7 +1320,7 @@ export default function mergeInDependentDataStructure({
     const postfixPrefixSet = new Set<string>();
     for (const postfixPath of postfixKeys) {
       if (!postfixPath) continue;
-      const parts = splitOutsideParenthesesAndArrays(postfixPath);
+      const parts = postfixPartsCache.get(postfixPath)!;
       for (let i = 1; i < parts.length; i++) {
         postfixPrefixSet.add(joinParenthesesAndArrays(parts.slice(0, i)));
       }
@@ -1242,7 +1341,13 @@ export default function mergeInDependentDataStructure({
       return true;
     });
 
+    // Cap schema size to prevent combinatorial explosion.
+    // Successful merges produce <3K ret keys. Beyond 5K, further postfixes
+    // add noise but no useful data — they're cross-products of unrelated equivalencies.
+    const SCHEMA_KEY_CAP = 5_000;
+
     for (const equivalentRoot of uniqueRoots) {
+      checkDeadline();
       let merged:
         | {
             signatureSchema: { [key: string]: string };
@@ -1262,9 +1367,13 @@ export default function mergeInDependentDataStructure({
         ? merged.signatureSchema
         : merged.returnValueSchema;
 
+      // Skip if this schema has already grown past the cap
+      if (Object.keys(schema).length > SCHEMA_KEY_CAP) continue;
+
       for (const [postfixPath, postfixValue] of Object.entries(
         esp.equivalentPostfixes,
       )) {
+        checkDeadline();
         let relevantPostfix = postfixPath;
         if (equivalentRoot.postfix) {
           // Check if postfixPath starts with equivalentRoot.postfix at a path boundary.
@@ -1284,10 +1393,18 @@ export default function mergeInDependentDataStructure({
           }
 
           const postFixPathParts =
+            postfixPartsCache.get(postfixPath) ??
             splitOutsideParenthesesAndArrays(postfixPath);
-          const equivalentRootPostFixParts = splitOutsideParenthesesAndArrays(
+          // Cache equivalentRoot.postfix parts — same root reused across all postfixes
+          if (!postfixPartsCache.has(equivalentRoot.postfix)) {
+            postfixPartsCache.set(
+              equivalentRoot.postfix,
+              splitOutsideParenthesesAndArrays(equivalentRoot.postfix),
+            );
+          }
+          const equivalentRootPostFixParts = postfixPartsCache.get(
             equivalentRoot.postfix,
-          );
+          )!;
           relevantPostfix = joinParenthesesAndArrays(
             postFixPathParts.slice(equivalentRootPostFixParts.length),
           );
@@ -1385,11 +1502,15 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  const postfixElapsed = Date.now() - mergeStartTime;
+
   // Batch-clean all modified schemas once (instead of once per root per ESP entry)
   for (const schema of schemasToClean) {
     cleanSchema(schema, { stage: 'afterMergePostfix' });
   }
 
+  const cleanElapsed = Date.now() - mergeStartTime;
+
   // Propagate equivalency-derived attributes to generic function call variants.
   // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
   // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
@@ -1415,6 +1536,7 @@ export default function mergeInDependentDataStructure({
       );
 
       for (const path in schemaToSearchForGenericVariants) {
+        checkDeadline();
         const match = path.match(genericRegex);
         if (match) {
           genericVariants.add(match[0]);
@@ -1428,6 +1550,7 @@ export default function mergeInDependentDataStructure({
       const pathsToAdd: [string, string][] = [];
 
       for (const path in returnValueSchema) {
+        checkDeadline();
         const value = returnValueSchema[path];
 
         // Handle returnValue. paths
@@ -1481,6 +1604,7 @@ export default function mergeInDependentDataStructure({
     // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
     for (const path in depSchema.returnValueSchema) {
+      checkDeadline();
       if (
         path === 'returnValue' ||
         path.startsWith('returnValue.') ||
@@ -1521,6 +1645,7 @@ export default function mergeInDependentDataStructure({
 
     // Now copy paths from the source schema (dependencySchemas)
     for (const path in srcSchema.returnValueSchema) {
+      checkDeadline();
       const value = srcSchema.returnValueSchema[path];
 
       // Normalize paths starting with 'returnValue' to use the standard format:
@@ -1714,9 +1839,11 @@ export default function mergeInDependentDataStructure({
       if (!existingSchema) {
         const depSchema = findOrCreateDependentSchemas({ filePath, name });
         for (const path in srcSchema.returnValueSchema) {
+          checkDeadline();
           depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
         }
         for (const path in srcSchema.signatureSchema) {
+          checkDeadline();
           depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
         }
 
@@ -1746,6 +1873,7 @@ export default function mergeInDependentDataStructure({
 
       if (childSignatureSchema) {
         for (const path in depSchema.signatureSchema) {
+          checkDeadline();
           const parentType = depSchema.signatureSchema[path];
           const childType = childSignatureSchema[path];
 
@@ -1794,6 +1922,7 @@ export default function mergeInDependentDataStructure({
 
           // Copy only paths that belong to this variant
           for (const path in srcSchema.returnValueSchema) {
+            checkDeadline();
             if (path.startsWith(variant)) {
               variantSchema.returnValueSchema[path] =
                 srcSchema.returnValueSchema[path];
@@ -1816,6 +1945,7 @@ export default function mergeInDependentDataStructure({
   // EXCEPT: Skip mocked dependencies - we don't want their internal implementation details.
   for (const filePath in dependentAnalyses) {
     for (const name in dependentAnalyses[filePath]) {
+      checkDeadline();
       const dependentMergedDataStructure =
         dependentAnalyses[filePath][name].metadata?.mergedDataStructure;
 
@@ -1832,6 +1962,7 @@ export default function mergeInDependentDataStructure({
         // Copy over all paths from the dependent's returnValueSchema
         // Only add paths that don't already exist (don't overwrite values set by equivalencies)
         for (const path in dependentMergedDataStructure.returnValueSchema) {
+          checkDeadline();
           const translatedPath = translatePath(path, name);
           if (!(translatedPath in depSchema.returnValueSchema)) {
             depSchema.returnValueSchema[translatedPath] =
@@ -1841,6 +1972,7 @@ export default function mergeInDependentDataStructure({
 
         // Copy over signature schema as well
         for (const path in dependentMergedDataStructure.signatureSchema) {
+          checkDeadline();
           const translatedPath = translatePath(path, name);
           if (!(translatedPath in depSchema.signatureSchema)) {
             depSchema.signatureSchema[translatedPath] =
@@ -1867,6 +1999,7 @@ export default function mergeInDependentDataStructure({
 
             // Merge in the nested dependency schemas
             for (const path in nestedDepSchema.returnValueSchema) {
+              checkDeadline();
               if (!(path in targetDepSchema.returnValueSchema)) {
                 const value = nestedDepSchema.returnValueSchema[path];
                 targetDepSchema.returnValueSchema[path] = value;
@@ -1874,6 +2007,7 @@ export default function mergeInDependentDataStructure({
             }
 
             for (const path in nestedDepSchema.signatureSchema) {
+              checkDeadline();
               if (!(path in targetDepSchema.signatureSchema)) {
                 targetDepSchema.signatureSchema[path] =
                   nestedDepSchema.signatureSchema[path];
@@ -1885,5 +2019,15 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  const totalElapsed = Date.now() - mergeStartTime;
+  const retKeys = Object.keys(mergedDataStructure.returnValueSchema).length;
+
+  // Only log phase breakdown for slow merges (>2s)
+  if (totalElapsed > 2000) {
+    console.log(
+      `CodeYam Log Level 2: ${rootScopeName} merge phases: gather=${gatherElapsed}ms mergeESP=${mergeEspElapsed - gatherElapsed}ms postfix=${postfixElapsed - mergeEspElapsed}ms clean=${cleanElapsed - postfixElapsed}ms depCopy=${totalElapsed - cleanElapsed}ms total=${totalElapsed}ms ret=${retKeys}`,
+    );
+  }
+
   return mergedDataStructure;
 }

package/codeyam-cli/src/commands/__tests__/editor.auditNoAutoAnalysis.test.js

@@ -0,0 +1,63 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Structural test: handleAudit must NOT call runAnalysisForEntities.
+ *
+ * Previously, handleAudit auto-ran targeted analysis for incomplete entities,
+ * which was slow (analyzer startup + AST scan) and contradicted the design
+ * intent (comment at line ~6255 says "We do NOT run handleAnalyzeImports here").
+ *
+ * This test ensures the auto-analysis doesn't creep back in.
+ */
+describe('handleAudit - no auto-analysis', () => {
+    it('should not call runAnalysisForEntities inside handleAudit', () => {
+        const editorTsPath = path.join(__dirname, '..', 'editor.ts');
+        const source = fs.readFileSync(editorTsPath, 'utf8');
+        // Extract the handleAudit function body.
+        // It starts with "async function handleAudit" and ends at the next
+        // top-level "async function" or "function" declaration (unindented).
+        const handleAuditStart = source.indexOf('async function handleAudit');
+        expect(handleAuditStart).toBeGreaterThan(-1);
+        // Find the next top-level function declaration after handleAudit starts.
+        // Top-level functions start at the beginning of a line (no indentation).
+        const afterStart = source.slice(handleAuditStart + 1);
+        const nextFnMatch = afterStart.match(/\n(?:async )?function [a-zA-Z]/);
+        const handleAuditEnd = nextFnMatch
+            ? handleAuditStart + 1 + nextFnMatch.index
+            : source.length;
+        const handleAuditBody = source.slice(handleAuditStart, handleAuditEnd);
+        // The function body must NOT contain runAnalysisForEntities
+        expect(handleAuditBody).not.toContain('runAnalysisForEntities');
+    });
+    it('should report incomplete entities with guidance instead of auto-fixing', () => {
+        const editorTsPath = path.join(__dirname, '..', 'editor.ts');
+        const source = fs.readFileSync(editorTsPath, 'utf8');
+        const handleAuditStart = source.indexOf('async function handleAudit');
+        const afterStart = source.slice(handleAuditStart + 1);
+        const nextFnMatch = afterStart.match(/\n(?:async )?function [a-zA-Z]/);
+        const handleAuditEnd = nextFnMatch
+            ? handleAuditStart + 1 + nextFnMatch.index
+            : source.length;
+        const handleAuditBody = source.slice(handleAuditStart, handleAuditEnd);
+        // Should still report incomplete entities
+        expect(handleAuditBody).toContain('incompleteEntities');
+        expect(handleAuditBody).toContain('formatIncompleteEntityGuidance');
+    });
+    it('should not call handleAnalyzeImports inside handleAudit', () => {
+        const editorTsPath = path.join(__dirname, '..', 'editor.ts');
+        const source = fs.readFileSync(editorTsPath, 'utf8');
+        const handleAuditStart = source.indexOf('async function handleAudit');
+        expect(handleAuditStart).toBeGreaterThan(-1);
+        const afterStart = source.slice(handleAuditStart + 1);
+        const nextFnMatch = afterStart.match(/\n(?:async )?function [a-zA-Z]/);
+        const handleAuditEnd = nextFnMatch
+            ? handleAuditStart + 1 + nextFnMatch.index
+            : source.length;
+        const handleAuditBody = source.slice(handleAuditStart, handleAuditEnd);
+        // handleAnalyzeImports calls runAnalysisForEntities internally —
+        // it takes minutes on large projects and contradicts the audit's
+        // read-only design intent.
+        expect(handleAuditBody).not.toContain('handleAnalyzeImports');
+    });
+});
+//# sourceMappingURL=editor.auditNoAutoAnalysis.test.js.map

package/codeyam-cli/src/commands/__tests__/editor.auditNoAutoAnalysis.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.auditNoAutoAnalysis.test.js","sourceRoot":"","sources":["../../../../../src/commands/__tests__/editor.auditNoAutoAnalysis.test.ts"],"names":[],"mappings":"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"}