@quenty/nevermore-cli 4.49.0 → 4.50.1

package/src/utils/testing/parsers/jest-lua-parser.ts

@@ -1,76 +1,79 @@
 /**
  * Parser for Jest-lua verbose output (`verbose=true, ci=true`).
  *
- * Handles two failure modes:
- *
- * 1. **Jest assertion failures** — `●` blocks:
- *    ```
- *      ● ObservableList > add and remove > should track count
- *
- *        expect(received).toEqual(expected)
- *
- *        Expected: 3
- *        Received: 2
- *
- *          at ServerScriptService.observablecollection.Shared.ObservableList.spec:45
- *    ```
- *
- * 2. **Runtime errors** — `Stack Begin`/`Stack End` blocks:
- *    ```
- *    Error: attempt to index nil with "Connect"
- *    Stack Begin
- *    Script 'ServerScriptService.maid.Shared.Maid.spec', Line 23
- *    Stack End
- *    ```
- *
- * The parser is intentionally lenient — it extracts what it can, skips what
- * it can't, and never crashes on unexpected input.
+ * Emits one diagnostic per `●` failure block and per `Stack Begin`/`Stack End`
+ * runtime error, at the innermost frame that resolves to a repo file,
+ * preferring the package under test. Diagnostics with no resolvable frame
+ * carry no file. Unexpected input is skipped, never thrown on.
  */
 
 import * as fs from 'fs';
+import * as path from 'path';
 import { type Diagnostic } from '@quenty/cli-output-helpers/reporting';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import type { SourcemapResolver } from '../../sourcemap/index.js';
-import { resolveRobloxTestPath } from './roblox-path-resolver.js';
+import type { AnnotationWorkspace } from './annotation-workspace.js';
+import { tryResolveRobloxSourceFile } from './roblox-path-resolver.js';
 
-/** Matches `at ServerScriptService.pkg.Path.spec:45` (with line number) */
-const AT_LOCATION_PATTERN = /^\s+at\s+(.+):(\d+)\s*$/;
+/** `at ServerScriptService.pkg.Path.spec:45`, line optional */
+const AT_FRAME_PATTERN = /^\s+at\s+(\S+?)(?::(\d+))?\s*$/;
 
-/** Matches `at ServerScriptService.pkg.Path.spec` (without line number) */
-const AT_LOCATION_NO_LINE_PATTERN = /^\s+at\s+(\S+)\s*$/;
+/** `ServerScriptService.pkg.Path:1263 function requireModule`, any service root */
+const BARE_FRAME_PATTERN =
+  /^\s+(\[string "[^"]+"\]|[A-Za-z_][\w-]*(?:\.[^\s:"]+)+):(\d+)(?:\s+function\s+\S+)?\s*$/;
 
-/** Matches `Script 'ServerScriptService.pkg.Path.spec', Line 23` */
-const SCRIPT_LOCATION_PATTERN = /Script '([^']+)', Line (\d+)/;
+/** `Script '[string "ServerScriptService.pkg.Path"]', Line 23` */
+const SCRIPT_FRAME_PATTERN = /Script '(.+?)', Line (\d+)/;
 
-/** Matches the Jest failure header: `● TestSuite > nested > test name` */
+/** `<chunk>:214:` location prefixes inside error messages */
+const MESSAGE_LOCATION_PATTERN =
+  /(\[string "[^"]+"\]|ServerScriptService\.[^\s:"]+):(\d+):/g;
+
+/** `● TestSuite › nested › test name` */
 const FAILURE_HEADER_PATTERN = /^\s*●\s+(.+)$/;
 
+const TITLE_SEPARATOR_PATTERN = / [›>] /;
+
 const enum State {
   IDLE,
   FAILURE_BLOCK,
   STACK_BLOCK,
 }
 
+interface Frame {
+  instancePath: string;
+  line?: number;
+}
+
 interface FailureContext {
   title: string;
   messageLines: string[];
-  file?: string;
-  line?: number;
+  frames: Frame[];
 }
 
 interface StackContext {
   errorMessage: string;
-  file?: string;
+  frames: Frame[];
+}
+
+interface ResolvedLocation {
+  file: string;
   line?: number;
+  isPackageUnderTest: boolean;
+}
+
+export interface JestLuaParseOptions {
+  /** npm name of the package under test, e.g. `@quenty/saveslot`. */
+  packageName: string;
+  sourcemapResolver?: SourcemapResolver;
+  workspace?: AnnotationWorkspace;
+  /** Repo root that holds the workspace. Defaults to cwd. */
+  repoRoot?: string;
 }
 
-/**
- * Search a `.spec.lua` file for an `it()` call matching `testName`.
- * Returns the 1-indexed line number, or `undefined` if not found.
- */
 function _findTestLineInFile(
   filePath: string,
-  testName: string
+  title: string
 ): number | undefined {
   let content: string;
   try {
@@ -80,31 +83,67 @@ function _findTestLineInFile(
   }
 
   const lines = content.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    if (
-      lines[i].includes(`it("${testName}"`) ||
-      lines[i].includes(`it('${testName}'`)
-    ) {
-      return i + 1;
-    }
+  const names = title.split(TITLE_SEPARATOR_PATTERN).map((name) => name.trim());
+  for (const name of names.reverse()) {
+    const index = lines.findIndex(
+      (line) => line.includes(`("${name}"`) || line.includes(`('${name}'`)
+    );
+    if (index !== -1) return index + 1;
   }
 
   return undefined;
 }
 
+function _parseFrameLine(rawLine: string): Frame | undefined {
+  const match =
+    rawLine.match(BARE_FRAME_PATTERN) ?? rawLine.match(AT_FRAME_PATTERN);
+  if (!match) return undefined;
+  return {
+    instancePath: match[1],
+    line: match[2] ? parseInt(match[2], 10) : undefined,
+  };
+}
+
+function _parseMessageLocations(message: string): Frame[] {
+  return [...message.matchAll(MESSAGE_LOCATION_PATTERN)].map((match) => ({
+    instancePath: match[1],
+    line: parseInt(match[2], 10),
+  }));
+}
+
+function _resolveLocation(
+  frames: Frame[],
+  options: JestLuaParseOptions
+): ResolvedLocation | undefined {
+  let fallback: ResolvedLocation | undefined;
+
+  for (const frame of frames) {
+    const resolved = tryResolveRobloxSourceFile(frame.instancePath, options);
+    if (!resolved) continue;
+
+    const location = { ...resolved, line: frame.line };
+    if (resolved.isPackageUnderTest) {
+      return location;
+    }
+    fallback ??= location;
+  }
+
+  return fallback;
+}
+
 /**
  * Parse Jest-lua verbose output into `Diagnostic[]`.
  *
  * @param raw - Raw test output (may include ANSI codes)
- * @param options.packageName - Package name for fallback path resolution
  */
 export function parseJestLuaOutput(
   raw: string,
-  options: { packageName: string; sourcemapResolver?: SourcemapResolver }
+  options: JestLuaParseOptions
 ): Diagnostic[] {
   const diagnostics: Diagnostic[] = [];
   const clean = OutputHelper.stripAnsi(raw);
   const lines = clean.split('\n');
+  const repoRoot = options.repoRoot ?? process.cwd();
 
   let state: State = State.IDLE;
   let failureCtx: FailureContext | undefined;
@@ -113,32 +152,19 @@ export function parseJestLuaOutput(
 
   function _emitFailure(ctx: FailureContext): void {
     const message = ctx.messageLines.join('\n').trim();
-
-    // 3-tier line resolution:
-    //  1. Primary: line number extracted from `at <path>:<line>` or similar
-    //  2. Secondary: search the resolved .spec.lua file for the it() call
-    //  3. Tertiary: fall back to line 1
-    let file: string;
-    let line: number;
-
-    if (ctx.file) {
-      file = resolveRobloxTestPath(ctx.file, options.sourcemapResolver);
-
-      if (ctx.line) {
-        line = ctx.line;
-      } else {
-        const segments = ctx.title.split(' > ');
-        const testName = segments[segments.length - 1].trim();
-        line = _findTestLineInFile(file, testName) ?? 1;
-      }
-    } else {
-      file = `src/${options.packageName}/src`;
-      line = 1;
+    const location = _resolveLocation(
+      [...ctx.frames, ..._parseMessageLocations(message)],
+      options
+    );
+
+    let line = location?.line;
+    if (location?.isPackageUnderTest && line === undefined) {
+      line = _findTestLineInFile(path.join(repoRoot, location.file), ctx.title);
     }
 
     diagnostics.push({
-      file,
-      line,
+      ...(location ? { file: location.file } : {}),
+      ...(line !== undefined ? { line } : {}),
       severity: 'error',
       title: ctx.title,
       message: message || 'Test failed',
@@ -147,14 +173,13 @@ export function parseJestLuaOutput(
   }
 
   function _emitStack(ctx: StackContext): void {
-    const file = ctx.file
-      ? resolveRobloxTestPath(ctx.file, options.sourcemapResolver)
-      : `src/${options.packageName}/src`;
-    const line = ctx.line ?? 1;
+    const location = _resolveLocation(
+      [...ctx.frames, ..._parseMessageLocations(ctx.errorMessage)],
+      options
+    );
 
     diagnostics.push({
-      file,
-      line,
+      ...(location ? { file: location.file, line: location.line ?? 1 } : {}),
       severity: 'error',
       title: 'Runtime error',
       message: ctx.errorMessage || 'Unknown runtime error',
@@ -162,7 +187,9 @@ export function parseJestLuaOutput(
     });
   }
 
-  for (const rawLine of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+
     switch (state) {
       case State.IDLE: {
         const failureMatch = rawLine.match(FAILURE_HEADER_PATTERN);
@@ -170,6 +197,7 @@ export function parseJestLuaOutput(
           failureCtx = {
             title: failureMatch[1].trim(),
             messageLines: [],
+            frames: [],
           };
           state = State.FAILURE_BLOCK;
           break;
@@ -178,6 +206,7 @@ export function parseJestLuaOutput(
         if (rawLine.trim() === 'Stack Begin') {
           stackCtx = {
             errorMessage: lastNonEmptyLine,
+            frames: [],
           };
           state = State.STACK_BLOCK;
           break;
@@ -195,32 +224,9 @@ export function parseJestLuaOutput(
           break;
         }
 
-        const atMatch = rawLine.match(AT_LOCATION_PATTERN);
-        if (atMatch) {
-          failureCtx.file = atMatch[1];
-          failureCtx.line = parseInt(atMatch[2], 10);
-          _emitFailure(failureCtx);
-          failureCtx = undefined;
-          state = State.IDLE;
-          break;
-        }
-
-        const atNoLineMatch = rawLine.match(AT_LOCATION_NO_LINE_PATTERN);
-        if (atNoLineMatch) {
-          failureCtx.file = atNoLineMatch[1];
-          _emitFailure(failureCtx);
-          failureCtx = undefined;
-          state = State.IDLE;
-          break;
-        }
-
-        const nextFailure = rawLine.match(FAILURE_HEADER_PATTERN);
-        if (nextFailure) {
-          _emitFailure(failureCtx);
-          failureCtx = {
-            title: nextFailure[1].trim(),
-            messageLines: [],
-          };
+        const frame = _parseFrameLine(rawLine);
+        if (frame) {
+          failureCtx.frames.push(frame);
           break;
         }
 
@@ -233,13 +239,27 @@ export function parseJestLuaOutput(
                     failureCtx.messageLines.length - 1
                   ].trim()
                 : failureCtx.title,
+            frames: [],
           };
           failureCtx = undefined;
           state = State.STACK_BLOCK;
           break;
         }
 
-        failureCtx.messageLines.push(rawLine);
+        const endsBlock =
+          FAILURE_HEADER_PATTERN.test(rawLine) ||
+          (failureCtx.frames.length > 0 && rawLine.trim() !== '');
+        if (endsBlock) {
+          _emitFailure(failureCtx);
+          failureCtx = undefined;
+          state = State.IDLE;
+          i--;
+          break;
+        }
+
+        if (failureCtx.frames.length === 0) {
+          failureCtx.messageLines.push(rawLine);
+        }
         break;
       }
 
@@ -249,10 +269,12 @@ export function parseJestLuaOutput(
           break;
         }
 
-        const scriptMatch = rawLine.match(SCRIPT_LOCATION_PATTERN);
+        const scriptMatch = rawLine.match(SCRIPT_FRAME_PATTERN);
         if (scriptMatch) {
-          stackCtx.file = scriptMatch[1];
-          stackCtx.line = parseInt(scriptMatch[2], 10);
+          stackCtx.frames.push({
+            instancePath: scriptMatch[1],
+            line: parseInt(scriptMatch[2], 10),
+          });
           break;
         }
 

package/src/utils/testing/parsers/roblox-path-resolver.test.ts

@@ -1,12 +1,35 @@
-import { describe, it, expect } from 'vitest';
-import { resolveRobloxTestPath } from './roblox-path-resolver.js';
+import { beforeAll, describe, it, expect } from 'vitest';
+import { fileURLToPath } from 'url';
+import { tryResolveRobloxSourceFile } from './roblox-path-resolver.js';
 import { SourcemapResolver } from '../../sourcemap/index.js';
 import type { SourcemapNode } from '../../sourcemap/index.js';
+import {
+  type AnnotationWorkspace,
+  tryLoadAnnotationWorkspaceAsync,
+} from './annotation-workspace.js';
 
-describe('resolveRobloxTestPath', () => {
+const REPO_ROOT = fileURLToPath(new URL('../../../../../../', import.meta.url));
+
+let workspace: AnnotationWorkspace | undefined;
+beforeAll(async () => {
+  workspace = await tryLoadAnnotationWorkspaceAsync(REPO_ROOT);
+}, 30000);
+
+function resolveFile(
+  instancePath: string,
+  packageName?: string
+): string | undefined {
+  return tryResolveRobloxSourceFile(instancePath, {
+    repoRoot: REPO_ROOT,
+    workspace,
+    packageName,
+  })?.file;
+}
+
+describe('tryResolveRobloxSourceFile', () => {
   it('resolves a standard ServerScriptService path', () => {
     expect(
-      resolveRobloxTestPath(
+      resolveFile(
         'ServerScriptService.observablecollection.Shared.ObservableList.spec'
       )
     ).toBe('src/observablecollection/src/Shared/ObservableList.spec.lua');
@@ -14,48 +37,121 @@ describe('resolveRobloxTestPath', () => {
 
   it('resolves a nested subdirectory path', () => {
     expect(
-      resolveRobloxTestPath('ServerScriptService.maid.Shared.Maid.spec')
-    ).toBe('src/maid/src/Shared/Maid.spec.lua');
+      resolveFile(
+        'ServerScriptService.observablecollection.Shared.SortedList.ObservableSortedList'
+      )
+    ).toBe(
+      'src/observablecollection/src/Shared/SortedList/ObservableSortedList.lua'
+    );
   });
 
-  it('resolves a deeply nested path', () => {
+  it('handles missing ServerScriptService prefix', () => {
+    expect(resolveFile('maid.Shared.MaidTaskUtils.spec')).toBe(
+      'src/maid/src/Shared/MaidTaskUtils.spec.lua'
+    );
+  });
+
+  it('unwraps a chunk-name wrapper', () => {
     expect(
-      resolveRobloxTestPath(
-        'ServerScriptService.blend.Client.Blend.Spring.SpringObject.spec'
+      resolveFile(
+        '[string "ServerScriptService.saveslot.Server.HasSaveSlotsDataStore"]'
       )
-    ).toBe('src/blend/src/Client/Blend/Spring/SpringObject.spec.lua');
+    ).toBe('src/saveslot/src/Server/HasSaveSlotsDataStore.lua');
   });
 
-  it('handles missing ServerScriptService prefix as fallback', () => {
+  it('maps a nested dependency copy to its own package', () => {
     expect(
-      resolveRobloxTestPath('observablecollection.Shared.ObservableList.spec')
-    ).toBe('src/observablecollection/src/Shared/ObservableList.spec.lua');
+      resolveFile(
+        'ServerScriptService.saveslot.node_modules.@quenty.adorneedata.node_modules.@quenty.attributeutils.node_modules.@quenty.baseobject.node_modules.@quenty.maid.Shared.Maid'
+      )
+    ).toBe('src/maid/src/Shared/Maid.lua');
   });
 
-  it('strips :LINE suffix', () => {
+  it('maps a dependency whose folder differs from its npm name', () => {
     expect(
-      resolveRobloxTestPath(
-        'ServerScriptService.observablecollection.Shared.ObservableList.spec:45'
+      resolveFile(
+        '[string "ServerScriptService.gameproduct.node_modules.@quenty.playermock.Shared.PlayerMock"]'
       )
-    ).toBe('src/observablecollection/src/Shared/ObservableList.spec.lua');
+    ).toBe('src/player-mock/src/Shared/PlayerMock.lua');
   });
 
-  it('handles path without ServerScriptService prefix and with :LINE suffix', () => {
-    expect(resolveRobloxTestPath('maid.Shared.Maid.spec:23')).toBe(
-      'src/maid/src/Shared/Maid.spec.lua'
-    );
+  it('resolves a package root module to its init file', () => {
+    expect(
+      resolveFile(
+        '[string "ServerScriptService.studiobridge.node_modules.@quenty.nevermore-test-runner.node_modules.@quenty.loader"]'
+      )
+    ).toBe('src/loader/src/init.lua');
   });
 
-  it('handles a bare package slug', () => {
-    expect(resolveRobloxTestPath('ServerScriptService.maid')).toBe(
-      'src/maid/src'
-    );
+  it('maps the test slug of the package under test to its folder', () => {
+    expect(
+      tryResolveRobloxSourceFile(
+        'ServerScriptService.gameproduct.Server.Cmdr.GameProductCmdrService',
+        {
+          repoRoot: REPO_ROOT,
+          workspace,
+          packageName: '@quenty/gameproductservice',
+        }
+      )
+    ).toEqual({
+      file: 'src/gameproductservice/src/Server/Cmdr/GameProductCmdrService.lua',
+      isPackageUnderTest: true,
+    });
+    expect(
+      resolveFile(
+        'ServerScriptService.playermock.Shared.PlayerMock',
+        '@quenty/playermock'
+      )
+    ).toBe('src/player-mock/src/Shared/PlayerMock.lua');
   });
 
-  it('handles a single-level spec path', () => {
-    expect(resolveRobloxTestPath('ServerScriptService.maid.Maid.spec')).toBe(
-      'src/maid/src/Maid.spec.lua'
-    );
+  it('resolves a package outside src/ by its workspace directory', () => {
+    expect(
+      resolveFile(
+        'ServerScriptService.studiobridge.commands.console.exec.execute.spec',
+        '@quenty/studio-bridge'
+      )
+    ).toBe('tools/studio-bridge/src/commands/console/exec/execute.spec.lua');
+  });
+
+  it('tries the script file names Rojo strips', () => {
+    expect(
+      resolveFile('ServerScriptService.x.node_modules.@quenty.preview-plugin')
+    ).toBe('plugins/preview-plugin/src/init.server.lua');
+  });
+
+  it('flags dependency frames as not under test', () => {
+    expect(
+      tryResolveRobloxSourceFile(
+        'ServerScriptService.saveslot.node_modules.@quenty.binder.Shared.Binder',
+        { repoRoot: REPO_ROOT, workspace, packageName: '@quenty/saveslot' }
+      )
+    ).toEqual({
+      file: 'src/binder/src/Shared/Binder.lua',
+      isPackageUnderTest: false,
+    });
+  });
+
+  it('does not remap a sibling package frame into the package under test', () => {
+    expect(
+      resolveFile(
+        'ServerScriptService.othersibling.Server.SaveSlotService',
+        '@quenty/saveslot'
+      )
+    ).toBeUndefined();
+    expect(
+      resolveFile('ServerScriptService.Script', '@quenty/saveslot')
+    ).toBeUndefined();
+  });
+
+  it('rejects vendored, truncated and missing paths', () => {
+    for (const instancePath of [
+      'ServerScriptService.studiobridge.node_modules.@quenty.nevermore-test-runner.node_modules.@quentystudios.Jest._Index.jsdotlua_promise@3.5.2.promise',
+      '[string "ServerScriptService.gameproduct.node_modules.@quenty.playermock.node_modules.@quenty.servic..."]',
+      'ServerScriptService.unknownpkg.Shared.Foo',
+    ]) {
+      expect(resolveFile(instancePath)).toBeUndefined();
+    }
   });
 
   describe('with sourcemap resolver', () => {
@@ -66,26 +162,19 @@ describe('resolveRobloxTestPath', () => {
       className: 'DataModel',
       children: [
         {
-          name: 'mypkg',
+          name: 'playermock',
           className: 'Folder',
-          filePaths: [`${repoRoot}/src/mypkg/default.project.json`],
+          filePaths: [`${repoRoot}/src/player-mock/default.project.json`],
           children: [
             {
               name: 'Shared',
               className: 'Folder',
               children: [
                 {
-                  name: 'MyModule',
+                  name: 'PlayerMock',
                   className: 'ModuleScript',
-                  filePaths: [`${repoRoot}/src/mypkg/src/Shared/MyModule.lua`],
-                  children: [
-                    {
-                      name: 'MyModule.spec',
-                      className: 'ModuleScript',
-                      filePaths: [
-                        `${repoRoot}/src/mypkg/src/Shared/MyModule.spec.lua`,
-                      ],
-                    },
+                  filePaths: [
+                    `${repoRoot}/src/player-mock/src/Shared/PlayerMock.lua`,
                   ],
                 },
               ],
@@ -97,31 +186,25 @@ describe('resolveRobloxTestPath', () => {
 
     const resolver = SourcemapResolver.fromSourcemap(sourcemap, repoRoot);
 
-    it('uses sourcemap when path is found', () => {
+    it('looks up dependency copies under their Rojo project name', () => {
       expect(
-        resolveRobloxTestPath(
-          'ServerScriptService.mypkg.Shared.MyModule.MyModule.spec',
-          resolver
-        )
-      ).toBe('src/mypkg/src/Shared/MyModule.spec.lua');
-    });
-
-    it('falls back to heuristic when sourcemap has no mapping', () => {
-      expect(
-        resolveRobloxTestPath(
-          'ServerScriptService.unknownpkg.Shared.Foo.spec',
-          resolver
-        )
-      ).toBe('src/unknownpkg/src/Shared/Foo.spec.lua');
+        tryResolveRobloxSourceFile(
+          'ServerScriptService.gameproduct.node_modules.@quenty.playermock.Shared.PlayerMock',
+          { repoRoot, sourcemapResolver: resolver }
+        )?.file
+      ).toBe('src/player-mock/src/Shared/PlayerMock.lua');
     });
 
-    it('strips :LINE suffix with sourcemap', () => {
+    it('returns undefined when neither sourcemap nor repo has the file', () => {
       expect(
-        resolveRobloxTestPath(
-          'ServerScriptService.mypkg.Shared.MyModule.MyModule.spec:42',
-          resolver
+        tryResolveRobloxSourceFile(
+          'ServerScriptService.unknownpkg.Shared.Foo',
+          {
+            repoRoot,
+            sourcemapResolver: resolver,
+          }
         )
-      ).toBe('src/mypkg/src/Shared/MyModule.spec.lua');
+      ).toBeUndefined();
     });
   });
 });