pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/input-modes/qa-analysis.js

@@ -0,0 +1,268 @@
+import { isRecord } from "../parsing.js";
+import { summarizeNetworkFailures } from "../results/network.js";
+import { stringifyUnknown } from "../results/text.js";
+import { getBatchResultItems, getCommandNameFromBatchItem, isStringArray } from "./shared.js";
+function expectedTextPreview(text) {
+    return JSON.stringify(text.length > 80 ? `${text.slice(0, 77)}...` : text);
+}
+function visibleTextWaitPassed(item, step) {
+    if (step.args[0] !== "wait" || step.args[1] !== "--fn") {
+        return undefined;
+    }
+    if (item.success === false) {
+        return false;
+    }
+    if (typeof item.result === "boolean") {
+        return item.result;
+    }
+    if (isRecord(item.result) && typeof item.result.result === "boolean") {
+        return item.result.result;
+    }
+    return true;
+}
+function textAssertionResult(item) {
+    if (item.success === false) {
+        return undefined;
+    }
+    const result = item.result;
+    if (typeof result === "string") {
+        return result;
+    }
+    if (!isRecord(result)) {
+        return undefined;
+    }
+    for (const key of ["result", "text", "value"]) {
+        if (typeof result[key] === "string") {
+            return result[key];
+        }
+    }
+    return undefined;
+}
+function subtractBaselineErrors(errors, baseline) {
+    const counts = new Map();
+    for (const error of baseline) {
+        const signature = stringifyUnknown(error);
+        counts.set(signature, (counts.get(signature) ?? 0) + 1);
+    }
+    let matchedCount = 0;
+    const novelErrors = errors.filter((error) => {
+        const signature = stringifyUnknown(error);
+        const count = counts.get(signature) ?? 0;
+        if (count === 0) {
+            return true;
+        }
+        counts.set(signature, count - 1);
+        matchedCount++;
+        return false;
+    });
+    return { matchedCount, novelErrors };
+}
+function isResetCommand(item) {
+    const command = item.command;
+    if (!isStringArray(command)) {
+        return false;
+    }
+    const [name, subcommand] = command;
+    return (command.includes("--clear") &&
+        (name === "console" || name === "errors" || (name === "network" && subcommand === "requests")));
+}
+function describeDiagnosticCheck(step) {
+    if (step.args.includes("--clear")) {
+        return undefined;
+    }
+    switch (step.args[0]) {
+        case "network":
+            return "network diagnostics";
+        case "console":
+            return "console diagnostics";
+        case "errors":
+            return step.generatedFrom === "qa.errorBaselineAfterClear"
+                ? undefined
+                : "page error diagnostics";
+        default:
+            return undefined;
+    }
+}
+function describePlannedCheck(step, checks) {
+    if (step.args[0] === "wait" && step.args[1] === "--load") {
+        return `load state: ${step.args[2]}`;
+    }
+    const selector = checks.expectedSelector;
+    if (selector !== undefined &&
+        selector.length > 0 &&
+        step.args[0] === "wait" &&
+        step.args[1] === selector) {
+        return `expected selector: ${expectedTextPreview(selector)}`;
+    }
+    if (step.action === "screenshot") {
+        return `screenshot: ${expectedTextPreview(step.args[1] ?? "")}`;
+    }
+    return describeDiagnosticCheck(step);
+}
+function describeNotRunChecks(compiled, count) {
+    let textIndex = 0;
+    const descriptions = compiled.steps.map((step) => {
+        if (step.action !== "assertText") {
+            return describePlannedCheck(step, compiled.checks);
+        }
+        const text = compiled.checks.expectedText.at(textIndex++);
+        return text === undefined || text.length === 0
+            ? undefined
+            : `expected text: ${expectedTextPreview(text)}`;
+    });
+    return descriptions
+        .slice(count)
+        .filter((description) => description !== undefined && description.length > 0);
+}
+function baselineIndex(compiled) {
+    if (compiled?.checks.diagnosticsResetAtStart !== true || !compiled.checks.checkErrors) {
+        return -1;
+    }
+    return compiled.steps.findIndex((step) => step.generatedFrom === "qa.errorBaselineAfterClear");
+}
+/** Owns one QA verdict; native diagnostic rows remain observations, not mutable state. */
+class QaVerdict {
+    failures = [];
+    warnings = [];
+    observeDiagnostic(item, baseline) {
+        const result = item.result;
+        if (!isRecord(result)) {
+            return;
+        }
+        switch (getCommandNameFromBatchItem(item)) {
+            case "errors":
+                this.observeErrors(result.errors, baseline);
+                break;
+            case "console":
+                this.observeConsole(result.messages);
+                break;
+            case "network":
+                this.observeNetwork(result.requests);
+                break;
+            case undefined:
+                break;
+            default:
+                break;
+        }
+    }
+    observeErrors(value, baseline) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return;
+        }
+        const { matchedCount, novelErrors } = subtractBaselineErrors(value, baseline);
+        if (novelErrors.length > 0) {
+            this.failures.push(`${novelErrors.length} page error(s)`);
+        }
+        if (matchedCount > 0) {
+            this.failures.push(`page-error check could not be verified (${matchedCount} row(s) matched the post-clear baseline; old residue and identical new errors are indistinguishable)`);
+        }
+    }
+    observeConsole(value) {
+        if (!Array.isArray(value)) {
+            return;
+        }
+        const errors = value.filter((message) => isRecord(message) && /error/i.test(stringifyUnknown(message.type ?? message.level ?? ""))).length;
+        if (errors > 0) {
+            this.failures.push(`${errors} console error message(s)`);
+        }
+    }
+    observeNetwork(value) {
+        if (!Array.isArray(value)) {
+            return;
+        }
+        const network = summarizeNetworkFailures(value);
+        if (network.actionableCount > 0) {
+            this.failures.push(`${network.actionableCount} actionable failed network request(s)`);
+        }
+        if (network.benignCount > 0) {
+            this.warnings.push(`${network.benignCount} benign network request failure(s) ignored`);
+        }
+    }
+    observeBatch(items, compiled) {
+        const baselineErrorIndex = baselineIndex(compiled);
+        const baselineResult = baselineErrorIndex >= 0 ? items.at(baselineErrorIndex)?.result : undefined;
+        const baseline = isRecord(baselineResult) && Array.isArray(baselineResult.errors) ? baselineResult.errors : [];
+        items.forEach((item, index) => {
+            if (item.success === false) {
+                this.failures.push(`${getCommandNameFromBatchItem(item) ?? "step"} failed`);
+            }
+            if (index === baselineErrorIndex ||
+                (compiled?.checks.diagnosticsResetAtStart === true && isResetCommand(item))) {
+                return;
+            }
+            this.observeDiagnostic(item, baseline);
+        });
+    }
+    observeExpectedText(items, compiled) {
+        let textIndex = 0;
+        compiled.steps.forEach((step, index) => {
+            if (step.action !== "assertText") {
+                return;
+            }
+            const expected = compiled.checks.expectedText.at(textIndex++);
+            const item = items.at(index);
+            if (expected === undefined || expected.length === 0 || item === undefined) {
+                return;
+            }
+            if (visibleTextWaitPassed(item, step) === true) {
+                return;
+            }
+            const actual = textAssertionResult(item);
+            if (actual === undefined || !actual.includes(expected)) {
+                this.failures.push(`expected text not found: ${expectedTextPreview(expected)}`);
+            }
+        });
+    }
+    finish(items, compiled) {
+        const stoppedEarly = compiled !== undefined && items.length < compiled.steps.length;
+        const failedFast = stoppedEarly && items.at(-1)?.success === false;
+        if (stoppedEarly && !failedFast) {
+            this.failures.push("QA execution could not be verified (incomplete batch results)");
+        }
+        const failedChecks = [...new Set(this.failures)];
+        const warnings = [...new Set(this.warnings)];
+        const notRunChecks = compiled !== undefined && failedFast ? describeNotRunChecks(compiled, items.length) : [];
+        return {
+            failedChecks,
+            warnings,
+            notRunChecks,
+            passed: failedChecks.length === 0,
+            summary: verdictSummary(failedChecks, warnings),
+        };
+    }
+}
+function verdictSummary(failures, warnings) {
+    if (failures.length > 0) {
+        return `QA preset failed: ${failures.join("; ")}.`;
+    }
+    return warnings.length === 0
+        ? "QA preset passed."
+        : `QA preset passed with warnings: ${warnings.join("; ")}.`;
+}
+export function analyzeQaPresetResults(data, compiled) {
+    const items = getBatchResultItems(data);
+    if (items.length === 0) {
+        return undefined;
+    }
+    const verdict = new QaVerdict();
+    verdict.observeBatch(items, compiled);
+    if (compiled !== undefined && compiled.checks.expectedText.length > 0) {
+        verdict.observeExpectedText(items, compiled);
+    }
+    return verdict.finish(items, compiled);
+}
+export function analyzeQaPresetTimeout(compiled) {
+    if (compiled.checks.expectedText.length === 0) {
+        return undefined;
+    }
+    const failedChecks = compiled.checks.expectedText.map((text) => `expected text was not verified before timeout: ${expectedTextPreview(text)}`);
+    return {
+        failedChecks,
+        notRunChecks: [],
+        passed: false,
+        summary: `QA preset failed: ${failedChecks.join("; ")}.`,
+        warnings: [
+            "The wrapper timed out before expected-text evidence could be verified; inspect timeoutPartialProgress and retry with a narrower readiness condition if the page was still loading.",
+        ],
+    };
+}

package/dist/extensions/agent-browser/lib/input-modes/qa-presentation.js

@@ -0,0 +1,117 @@
+import { isRecord } from "../parsing.js";
+import { truncateText } from "../results/text.js";
+import { getBatchResultItems, getCommandNameFromBatchItem } from "./shared.js";
+function hasPageContext(page) {
+    return (page?.title?.length ?? 0) > 0 || (page?.url?.length ?? 0) > 0;
+}
+function pageLine(page) {
+    const parts = [page?.title, page?.url].filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length === 0 ? [] : [`Page: ${parts.join(" — ")}`];
+}
+function describeChecks(checks) {
+    const parts = [`load:${checks.loadState}`];
+    if (checks.expectedText.length > 0) {
+        parts.push(`text×${checks.expectedText.length}`);
+    }
+    const enabledChecks = [
+        ["selector", (checks.expectedSelector ?? "").length > 0],
+        ["network", checks.checkNetwork],
+        ["console", checks.checkConsole],
+        ["errors", checks.checkErrors],
+    ];
+    for (const [name, enabled] of enabledChecks) {
+        if (enabled) {
+            parts.push(name);
+        }
+    }
+    if (checks.diagnosticsResetAtStart) {
+        parts.push("diagnostics-reset");
+    }
+    else if (hasDiagnostics(checks)) {
+        parts.push("attached-diagnostics-preserved");
+    }
+    if ((checks.screenshotPath ?? "").length > 0) {
+        parts.push("screenshot");
+    }
+    return parts.join(", ");
+}
+function hasDiagnostics(checks) {
+    return checks.checkNetwork || checks.checkConsole || checks.checkErrors;
+}
+function isolationLines(checks) {
+    if (!hasDiagnostics(checks)) {
+        return [];
+    }
+    if (checks.diagnosticsResetAtStart) {
+        return [
+            "Diagnostic isolation: URL QA requests clears of enabled diagnostic buffers before opening the target.",
+        ];
+    }
+    if (checks.attached) {
+        return [
+            "Attached diagnostics: existing upstream session console/network/error buffers were preserved; rows may include events from before qa.attached started.",
+        ];
+    }
+    return [];
+}
+export function extractQaPageContext(options) {
+    if (hasPageContext(options.attachedTarget)) {
+        return { title: options.attachedTarget?.title, url: options.attachedTarget?.url };
+    }
+    const page = extractBatchPageContext(options.batchData);
+    if (page !== undefined) {
+        return page;
+    }
+    const url = options.compiled?.checks.url;
+    return url === undefined || url.length === 0 ? {} : { url };
+}
+function extractBatchPageContext(data) {
+    for (const item of getBatchResultItems(data)) {
+        if (getCommandNameFromBatchItem(item) !== "open" || !isRecord(item.result)) {
+            continue;
+        }
+        const page = {
+            url: typeof item.result.url === "string" ? item.result.url : undefined,
+            title: typeof item.result.title === "string" ? item.result.title : undefined,
+        };
+        if (hasPageContext(page)) {
+            return page;
+        }
+    }
+    return undefined;
+}
+export function buildQaCompactPassText(options) {
+    const lines = [options.qaPreset.summary, ...pageLine(options.page)];
+    lines.push(`Checks run: ${describeChecks(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
+    lines.push(...isolationLines(options.checks));
+    const path = options.checks.screenshotPath;
+    if (path !== undefined && path.length > 0) {
+        const verification = options.artifactVerification;
+        lines.push(verification
+            ? `Screenshot: ${path} (${verification.verifiedCount}/${verification.artifacts.length} verified on disk)`
+            : `Screenshot: ${path}`);
+    }
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}
+export function buildQaCompactFailureText(options) {
+    const error = options.causalError;
+    const lines = [
+        error !== undefined && error.length > 0
+            ? truncateText(error.replace(/\s+/g, " ").trim(), 700)
+            : options.qaPreset.summary,
+        ...pageLine(options.page),
+    ];
+    for (const [label, entries] of [
+        ["Failed checks:", options.qaPreset.failedChecks],
+        ["Not run:", options.qaPreset.notRunChecks],
+        ["Warnings:", options.qaPreset.warnings],
+    ]) {
+        if (entries.length > 0) {
+            lines.push(label, ...entries.map((entry) => `- ${entry}`));
+        }
+    }
+    lines.push(`Execution: ${options.executedStepCount ?? "unknown"}/${options.plannedStepCount} batch steps`);
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}