donobu 5.41.3 → 5.42.0

package/dist/esm/lib/ai/PageAi.js

@@ -150,6 +150,7 @@ class PageAi {
     async ai(page, instruction, options) {
         const startedAt = Date.now();
         let cacheHit = false;
+        let cacheStored = false;
         let thrownError = undefined;
         try {
             const descriptor = this.buildDescriptor(page, instruction, options);
@@ -197,6 +198,7 @@ class PageAi {
                     }, this.donobu.toolRegistry);
                     const cacheEntry = cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(descriptor.key.pageUrl, runResult.donobuFlow.metadata, preparedToolCalls);
                     await this.cache.put(cacheEntry);
+                    cacheStored = true;
                 }
                 return runResult.parsedResult;
             }
@@ -212,6 +214,7 @@ class PageAi {
                 startedAt,
                 endedAt: Date.now(),
                 cacheHit,
+                cacheStored,
                 passed: thrownError === undefined,
                 error: thrownError !== undefined
                     ? { message: thrownError?.message }

package/dist/esm/lib/page/DonobuExtendedPage.d.ts

@@ -488,10 +488,40 @@ export interface AiInvocationRecord {
     startedAt: number;
     endedAt: number;
     cacheHit: boolean;
+    /**
+     * For live (non-replay) invocations: `true` once this run successfully
+     * wrote an entry into the relevant page-AI cache, `false` if a write was
+     * attempted (or would have been) but didn't land. Combined with
+     * `cacheHit`, this gives the reporter a tri-state cache outcome — hit
+     * (replayed), stored (live + recorded), or miss (live + nothing cached).
+     * Always `false` when `cacheHit` is `true`.
+     */
+    cacheStored: boolean;
     passed: boolean;
     error?: {
         message?: string;
     };
+    /**
+     * For live `page.ai.assert` runs: metadata about the post-pass structured
+     * step verification. After the AI judges the assertion passed against a
+     * screenshot, AssertTool re-executes the AI-emitted Playwright `expect()`
+     * calls against the page to decide whether those structured steps are
+     * cache-worthy. When `failed: true`, the AI's visual verdict still stands
+     * — the tool returns success — but one of the structured `expect()` calls
+     * underneath threw. The reporter uses this to surface the divergence as a
+     * labelled signal rather than render the inner expect failure as a regular
+     * assertion failure.
+     *
+     * Undefined when verification didn't run (no structured steps emitted, AI
+     * verdict was failed, cached replay path, or AssertTool invoked outside
+     * the page.ai.assert wrapper).
+     */
+    verification?: {
+        startedAt: number;
+        endedAt: number;
+        failed: boolean;
+        errorMessage?: string;
+    };
     /**
      * For cached `page.ai.assert` invocations: the structured Playwright
      * assertion steps that were replayed. The reporter formats these back

package/dist/esm/lib/page/extendPage.js

@@ -220,8 +220,10 @@ Valid options:
         assert: async (assertion, options) => {
             const aiInvocationStartedAt = Date.now();
             let aiInvocationCacheHit = false;
+            let aiInvocationCacheStored = false;
             let aiInvocationError = undefined;
             let aiInvocationAssertSteps;
+            let aiInvocationVerification;
             try {
                 const useCache = options?.cache !== false;
                 const clearCache = sharedState.runtimeDirectives?.clearPageAiCache ?? false;
@@ -322,6 +324,7 @@ Valid options:
                 finally {
                     sharedState.envVals = previousEnvVals;
                 }
+                aiInvocationVerification = result.outcome.metadata?.verification;
                 if (!result.outcome.isSuccessful) {
                     throw new ToolCallFailedException_1.ToolCallFailedException(AssertTool_1.AssertTool.NAME, result.outcome);
                 }
@@ -333,6 +336,7 @@ Valid options:
                             const cache = getOrInitPageAiCache();
                             const pageUrl = (0, cacheLocator_1.extractCacheKeyHostname)(page.url());
                             await cache.putAssert({ pageUrl, assertion, steps });
+                            aiInvocationCacheStored = true;
                             Logger_1.appLogger.debug(`Assert cache STORED for: "${assertion}"`);
                         }
                         catch (error) {
@@ -352,11 +356,13 @@ Valid options:
                     startedAt: aiInvocationStartedAt,
                     endedAt: Date.now(),
                     cacheHit: aiInvocationCacheHit,
+                    cacheStored: aiInvocationCacheStored,
                     passed: aiInvocationError === undefined,
                     error: aiInvocationError !== undefined
                         ? { message: aiInvocationError?.message }
                         : undefined,
                     assertSteps: aiInvocationAssertSteps,
+                    verification: aiInvocationVerification,
                 });
             }
         },
@@ -434,6 +440,7 @@ Use this information to return an appropriate JSON object.`,
         locate: async (description, options) => {
             const aiInvocationStartedAt = Date.now();
             let aiInvocationCacheHit = false;
+            let aiInvocationCacheStored = false;
             let aiInvocationError = undefined;
             const useCache = options?.cache !== false;
             const clearCache = sharedState.runtimeDirectives?.clearPageAiCache ?? false;
@@ -525,6 +532,7 @@ Use this information to return an appropriate JSON object.`,
                     try {
                         const cache = getOrInitPageAiCache();
                         await cache.putLocate({ pageUrl, description, result });
+                        aiInvocationCacheStored = true;
                         Logger_1.appLogger.debug(`Locate cache STORED for: "${description}"`);
                     }
                     catch (error) {
@@ -545,6 +553,7 @@ Use this information to return an appropriate JSON object.`,
                     startedAt: aiInvocationStartedAt,
                     endedAt: Date.now(),
                     cacheHit: aiInvocationCacheHit,
+                    cacheStored: aiInvocationCacheStored,
                     passed: aiInvocationError === undefined,
                     error: aiInvocationError !== undefined
                         ? { message: aiInvocationError?.message }

package/dist/esm/reporter/buildReport.js

@@ -48,6 +48,10 @@ function buildDonobuReport(resultsByTest, rootDir) {
             const testEntries = tests.map((test) => {
                 const results = resultsByTest.get(test) ?? [];
                 return {
+                    // Playwright's stable per-(file, project, title) ID — used by the
+                    // merge step's `byId` index and by the HTML renderer for permalink
+                    // anchors (`index.html#?testId=<id>`) and the per-test redirect stubs.
+                    testId: test.id,
                     annotations: test.annotations,
                     tags: test.tags,
                     projectName: getProjectName(test),

package/dist/esm/reporter/html.d.ts

@@ -51,5 +51,16 @@ export default class DonobuHtmlReporter implements Reporter {
     onTestEnd(test: TestCase, result: TestResult): void;
     onEnd(_result: FullResult): Promise<void>;
     printsToStdio(): boolean;
+    /**
+     * Drop a tiny redirect `index.html` into each Playwright-managed per-test
+     * directory under `outputDir`. The stub points back at the combined report's
+     * `#?testId=<id>` deep link, giving every test a stable URL inside its own
+     * directory without duplicating any of the rendered HTML.
+     *
+     * Directories are discovered from `dirname(attachment.path)` — Donobu does
+     * not invent any directory naming or layout. Tests with no attachments (and
+     * therefore no Playwright-created directory) get no stub.
+     */
+    private writePerTestStubs;
 }
 //# sourceMappingURL=html.d.ts.map

package/dist/esm/reporter/html.js

@@ -82,10 +82,65 @@ class DonobuHtmlReporter {
         (0, fs_1.mkdirSync)(outputDir, { recursive: true });
         (0, fs_1.writeFileSync)(outputFile, html, 'utf8');
         Logger_1.appLogger.info(`Donobu report written to ${outputFile}`);
+        this.writePerTestStubs(outputFile, outputDir);
     }
     printsToStdio() {
         return false;
     }
+    /**
+     * Drop a tiny redirect `index.html` into each Playwright-managed per-test
+     * directory under `outputDir`. The stub points back at the combined report's
+     * `#?testId=<id>` deep link, giving every test a stable URL inside its own
+     * directory without duplicating any of the rendered HTML.
+     *
+     * Directories are discovered from `dirname(attachment.path)` — Donobu does
+     * not invent any directory naming or layout. Tests with no attachments (and
+     * therefore no Playwright-created directory) get no stub.
+     */
+    writePerTestStubs(outputFile, outputDir) {
+        for (const [test, results] of this.resultsByTest) {
+            if (!test.id) {
+                continue;
+            }
+            const testDirs = new Set();
+            for (const result of results) {
+                for (const att of result.attachments) {
+                    if (!att.path) {
+                        continue;
+                    }
+                    const attDir = (0, path_1.dirname)((0, path_1.resolve)(att.path));
+                    const rel = (0, path_1.relative)(outputDir, attDir);
+                    if (!rel || rel.startsWith('..')) {
+                        // Attachment lives outside the report's output directory — skip;
+                        // we shouldn't be writing into arbitrary paths.
+                        continue;
+                    }
+                    testDirs.add(attDir);
+                }
+            }
+            if (testDirs.size === 0) {
+                continue;
+            }
+            const fileBase = test.location.file.split('/').pop() ?? test.location.file;
+            const title = `${fileBase} › ${test.title}`;
+            for (const testDir of testDirs) {
+                const stubPath = (0, path_1.resolve)(testDir, 'index.html');
+                const relPathToReport = (0, path_1.relative)(testDir, outputFile);
+                const stub = (0, render_1.renderPerTestStub)({
+                    testId: test.id,
+                    title,
+                    relPathToReport,
+                });
+                try {
+                    (0, fs_1.mkdirSync)(testDir, { recursive: true });
+                    (0, fs_1.writeFileSync)(stubPath, stub, 'utf8');
+                }
+                catch (err) {
+                    Logger_1.appLogger.warn(`Failed to write per-test redirect stub at ${stubPath}: ${err.message}`);
+                }
+            }
+        }
+    }
 }
 exports.default = DonobuHtmlReporter;
 //# sourceMappingURL=html.js.map

package/dist/esm/reporter/render.d.ts

@@ -140,5 +140,20 @@ export interface TriageData {
 }
 export declare function loadTriageData(triageDir: string): TriageData;
 export declare function renderHtml(report: DonobuReport, triage: TriageData, outputDir: string | null): string;
+/**
+ * Render the tiny redirect HTML that Donobu drops into each Playwright-managed
+ * per-test directory under `test-results/`. The stub bounces straight to the
+ * combined report's `#?testId=<id>` deep link — meta-refresh + JS replace +
+ * visible fallback link, so it works with or without JS, online or `file://`.
+ *
+ * Strictly additive: Donobu does not create or rename Playwright's per-test
+ * directories — the caller in `html.ts` only writes this file into directories
+ * Playwright already created for the test's attachments.
+ */
+export declare function renderPerTestStub(params: {
+    testId: string;
+    title: string;
+    relPathToReport: string;
+}): string;
 export {};
 //# sourceMappingURL=render.d.ts.map