@teaflask/assistant 0.0.0 → 0.6.0

package/dist/reader/read-page.js

@@ -0,0 +1,130 @@
+import { boundedTextOf, doorCostOfText } from "../transport/door-budget.js";
+import { unifiedDiffOf } from "./line-diff.js";
+import { pageHeaderOf, renderedTreeOf } from "./render.js";
+import { DEFAULT_MAX_DEPTH, resolvedSnapshotRootOf, snapshotTreeOf, } from "./snapshot.js";
+const READ_PAGE_CONTENT_MAX_CHARS = 16_000;
+const DEPTH_LADDER = [30, 20, 12, 8, 5, 3];
+const TRUNCATION_NOTICE = "… [truncated: the page holds more than fits here]";
+const MAX_TITLE_LENGTH = 300;
+const MAX_URL_LENGTH = 2_000;
+export class SnapshotUnavailableError extends Error {
+}
+const _baselineByThread = new Map();
+export function readPageResultOf(threadId, action, probe) {
+    const request = _readRequestOf(action, probe);
+    const scope = _scopeKeyOf(request);
+    const fitted = _fittedTreeTextOf(request);
+    const content = _cheaperOfDiffAndFull(threadId, scope, fitted);
+    _baselineByThread.set(threadId, {
+        scope,
+        shape: fitted.shape,
+        text: fitted.text,
+    });
+    return {
+        url: boundedTextOf(document.location.href, MAX_URL_LENGTH),
+        title: boundedTextOf(document.title.replace(/\s+/g, " ").trim(), MAX_TITLE_LENGTH),
+        content: content.text,
+        is_diff: content.isDiff,
+        truncated: fitted.truncated,
+    };
+}
+export function _resetBaselinesForTests() {
+    _baselineByThread.clear();
+}
+function _readRequestOf(action, probe) {
+    return {
+        probe,
+        ignoreSelectors: _stringListOf(action?.ignore_selectors),
+        maxDepth: _depthOf(action?.max_depth),
+        interactive: action?.interactive === true,
+        showHidden: action?.show_hidden === true,
+        selector: _nonEmptyStringOf(action?.selector),
+        refId: _nonEmptyStringOf(action?.ref_id),
+        rootElement: null,
+    };
+}
+function _fittedTreeTextOf(request) {
+    const rooting = resolvedSnapshotRootOf(request);
+    if (rooting.error !== null) {
+        throw new SnapshotUnavailableError(rooting.error);
+    }
+    const pinned = { ...request, rootElement: rooting.root };
+    const header = pageHeaderOf(document.title, document.location.href);
+    const fullText = `${header}\n${_renderedSnapshotOf(pinned)}`;
+    if (doorCostOfText(fullText) <= READ_PAGE_CONTENT_MAX_CHARS) {
+        return { text: fullText, truncated: false, shape: "full" };
+    }
+    for (const rung of DEPTH_LADDER) {
+        if (rung >= pinned.maxDepth) {
+            continue;
+        }
+        const shallower = `${header}\n${_renderedSnapshotOf({ ...pinned, maxDepth: rung })}`;
+        if (doorCostOfText(shallower) <= READ_PAGE_CONTENT_MAX_CHARS) {
+            return {
+                text: shallower,
+                truncated: true,
+                shape: `depth:${String(rung)}`,
+            };
+        }
+    }
+    const fullTextAgain = `${header}\n${_renderedSnapshotOf(pinned)}`;
+    return {
+        text: _lineBoundedTextOf(fullTextAgain),
+        truncated: true,
+        shape: "line-bounded",
+    };
+}
+function _renderedSnapshotOf(request) {
+    const outcome = snapshotTreeOf(request);
+    if (outcome.error !== null) {
+        throw new SnapshotUnavailableError(outcome.error);
+    }
+    return renderedTreeOf(outcome.tree);
+}
+function _cheaperOfDiffAndFull(threadId, scope, fitted) {
+    const baseline = _baselineByThread.get(threadId);
+    if (baseline?.scope !== scope || baseline.shape !== fitted.shape) {
+        return { text: fitted.text, isDiff: false };
+    }
+    if (fitted.shape === "line-bounded") {
+        return { text: fitted.text, isDiff: false };
+    }
+    const diff = unifiedDiffOf(baseline.text, fitted.text);
+    if (doorCostOfText(diff) < doorCostOfText(fitted.text)) {
+        return { text: diff, isDiff: true };
+    }
+    return { text: fitted.text, isDiff: false };
+}
+function _scopeKeyOf(request) {
+    return JSON.stringify({
+        url: document.location.href,
+        interactive: request.interactive,
+        maxDepth: request.maxDepth,
+        showHidden: request.showHidden,
+        selector: request.selector,
+        refId: request.refId,
+        ignoreSelectors: request.ignoreSelectors,
+    });
+}
+function _lineBoundedTextOf(text) {
+    const noticeCost = doorCostOfText(`\n${TRUNCATION_NOTICE}`);
+    const bounded = boundedTextOf(text, READ_PAGE_CONTENT_MAX_CHARS - noticeCost);
+    const lastLineBreak = bounded.lastIndexOf("\n");
+    const wholeLines = lastLineBreak > 0 ? bounded.slice(0, lastLineBreak) : bounded;
+    return `${wholeLines}\n${TRUNCATION_NOTICE}`;
+}
+function _depthOf(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        return DEFAULT_MAX_DEPTH;
+    }
+    return Math.min(value, DEFAULT_MAX_DEPTH);
+}
+function _nonEmptyStringOf(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+function _stringListOf(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((member) => typeof member === "string" && member !== "");
+}

package/dist/reader/redaction.d.ts

@@ -0,0 +1,3 @@
+export declare const REDACTED_VALUE = "[redacted]";
+export declare function textboxValueOf(element: Element): string | null;
+export declare function theFieldHoldsASecret(element: HTMLInputElement | HTMLTextAreaElement): boolean;

package/dist/reader/redaction.js

@@ -0,0 +1,49 @@
+import { isContentEditableElement } from "./roles.js";
+export const REDACTED_VALUE = "[redacted]";
+const SENSITIVE_AUTOCOMPLETE_VALUES = new Set([
+    "cc-number",
+    "cc-csc",
+    "current-password",
+    "new-password",
+    "one-time-code",
+]);
+export function textboxValueOf(element) {
+    if (isContentEditableElement(element)) {
+        const rendered = Reflect.get(element, "innerText");
+        if (typeof rendered === "string") {
+            return rendered;
+        }
+        return element.textContent;
+    }
+    if (!(element instanceof HTMLInputElement) &&
+        !(element instanceof HTMLTextAreaElement)) {
+        return null;
+    }
+    if (element instanceof HTMLInputElement) {
+        const type = element.type;
+        if (type === "checkbox" ||
+            type === "radio" ||
+            type === "file" ||
+            type === "hidden") {
+            return null;
+        }
+        if (type === "password") {
+            return element.value === "" ? "" : REDACTED_VALUE;
+        }
+    }
+    if (theFieldHoldsASecret(element) && element.value !== "") {
+        return REDACTED_VALUE;
+    }
+    return element.value;
+}
+export function theFieldHoldsASecret(element) {
+    const autocomplete = (element.getAttribute("autocomplete") ?? "")
+        .trim()
+        .toLowerCase();
+    if (autocomplete === "") {
+        return false;
+    }
+    return autocomplete
+        .split(/\s+/)
+        .some((token) => SENSITIVE_AUTOCOMPLETE_VALUES.has(token) || token.startsWith("cc-exp"));
+}

package/dist/reader/render.d.ts

@@ -0,0 +1,3 @@
+import type { SnapshotNode } from "./snapshot.js";
+export declare function pageHeaderOf(title: string, url: string): string;
+export declare function renderedTreeOf(root: SnapshotNode): string;

package/dist/reader/render.js

@@ -0,0 +1,117 @@
+import { boundedTextOf } from "../transport/door-budget.js";
+const MAX_TITLE_LENGTH = 300;
+const MAX_URL_LENGTH = 2_000;
+const MAX_OPTION_TEXT_LENGTH = 100;
+export function pageHeaderOf(title, url) {
+    const boundedTitle = boundedTextOf(title.replace(/\s+/g, " ").trim(), MAX_TITLE_LENGTH);
+    const boundedUrl = boundedTextOf(url, MAX_URL_LENGTH);
+    return `# page: "${_escapedText(boundedTitle)}"\n# url: ${boundedUrl}`;
+}
+export function renderedTreeOf(root) {
+    const lines = [];
+    _renderChildren(root, 0, lines);
+    return lines.join("\n");
+}
+function _renderChildren(node, depth, lines) {
+    for (const child of node.children) {
+        if (typeof child === "string") {
+            const text = child.trim();
+            if (text !== "") {
+                lines.push(`${_indentOf(depth)}- text: "${_escapedText(text)}"`);
+            }
+        }
+        else {
+            _renderNode(child, depth, lines);
+        }
+    }
+}
+function _renderNode(node, depth, lines) {
+    const indent = _indentOf(depth);
+    const label = _nodeLineOf(node);
+    const isSelect = node.element instanceof HTMLSelectElement;
+    const textChildren = node.children.filter((child) => typeof child === "string");
+    const elementChildren = node.children.filter((child) => typeof child !== "string");
+    if (textChildren.length === 1 && elementChildren.length === 0 && !isSelect) {
+        const text = textChildren[0].trim();
+        if (text === "") {
+            lines.push(`${indent}- ${label}`);
+        }
+        else {
+            lines.push(`${indent}- ${label}: "${_escapedText(text)}"`);
+        }
+        return;
+    }
+    if (node.children.length === 0 && !isSelect) {
+        lines.push(`${indent}- ${label}`);
+        return;
+    }
+    lines.push(`${indent}- ${label}:`);
+    if (isSelect && node.element instanceof HTMLSelectElement) {
+        _renderSelectOptions(node.element, depth + 1, lines);
+        return;
+    }
+    _renderChildren(node, depth + 1, lines);
+}
+function _renderSelectOptions(select, depth, lines) {
+    const indent = _indentOf(depth);
+    for (const option of Array.from(select.options)) {
+        const text = option.text
+            .replace(/\s+/g, " ")
+            .trim()
+            .substring(0, MAX_OPTION_TEXT_LENGTH);
+        let line = `${indent}- option "${_escapedText(text)}"`;
+        if (option.selected) {
+            line += " (selected)";
+        }
+        if (option.value !== text) {
+            line += ` value="${_escapedText(option.value)}"`;
+        }
+        lines.push(line);
+    }
+}
+function _nodeLineOf(node) {
+    const parts = [node.role];
+    if (node.name !== "") {
+        parts.push(`"${_escapedText(node.name)}"`);
+    }
+    if (node.refId !== null) {
+        parts.push(`[ref=${node.refId}]`);
+    }
+    if (node.level !== null && node.level > 0) {
+        parts.push(`[level=${String(node.level)}]`);
+    }
+    if (node.hidden) {
+        parts.push("[hidden]");
+    }
+    if (node.offscreen) {
+        parts.push("[offscreen]");
+    }
+    if (node.scrollable) {
+        parts.push("[scrollable]");
+    }
+    if (node.checked) {
+        parts.push("[checked]");
+    }
+    if (node.disabled) {
+        parts.push("[disabled]");
+    }
+    if (node.focused) {
+        parts.push("[focused]");
+    }
+    if (node.selected) {
+        parts.push("[selected]");
+    }
+    if (node.placeholder !== null && node.placeholder !== "") {
+        parts.push(`[placeholder="${_escapedText(node.placeholder)}"]`);
+    }
+    if (node.hints.length > 0) {
+        parts.push(`[${node.hints.join(" ")}]`);
+    }
+    return parts.join(" ");
+}
+function _escapedText(text) {
+    return text.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function _indentOf(depth) {
+    return "  ".repeat(depth);
+}

package/dist/reader/roles.d.ts

@@ -0,0 +1,8 @@
+export declare const ARIA_SELECTED_ROLES: Set<string>;
+export declare const ARIA_CHECKED_ROLES: Set<string>;
+export declare const ARIA_DISABLED_ROLES: Set<string>;
+export declare function roleOf(element: Element): string;
+export declare function explicitRoleOf(element: Element): string | null;
+export declare function ariaLevelOf(element: Element, role: string): number | null;
+export declare function ariaBooleanOf(attribute: string | null): boolean | undefined;
+export declare function isContentEditableElement(element: Element): boolean;

package/dist/reader/roles.js

@@ -0,0 +1,245 @@
+const IMPLICIT_ROLE_BY_TAG = {
+    a: "link",
+    button: "button",
+    iframe: "iframe",
+    select: "combobox",
+    textarea: "textbox",
+    h1: "heading",
+    h2: "heading",
+    h3: "heading",
+    h4: "heading",
+    h5: "heading",
+    h6: "heading",
+    canvas: "canvas",
+    svg: "image",
+    img: "image",
+    nav: "navigation",
+    main: "main",
+    header: "banner",
+    footer: "contentinfo",
+    section: "region",
+    article: "article",
+    aside: "complementary",
+    form: "form",
+    fieldset: "group",
+    table: "table",
+    ul: "list",
+    ol: "list",
+    li: "listitem",
+    p: "paragraph",
+    label: "label",
+};
+const VALID_ARIA_ROLES = new Set([
+    "alert",
+    "alertdialog",
+    "application",
+    "article",
+    "banner",
+    "blockquote",
+    "button",
+    "caption",
+    "cell",
+    "checkbox",
+    "code",
+    "columnheader",
+    "combobox",
+    "complementary",
+    "contentinfo",
+    "definition",
+    "deletion",
+    "dialog",
+    "directory",
+    "document",
+    "emphasis",
+    "feed",
+    "figure",
+    "form",
+    "generic",
+    "grid",
+    "gridcell",
+    "group",
+    "heading",
+    "img",
+    "insertion",
+    "link",
+    "list",
+    "listbox",
+    "listitem",
+    "log",
+    "main",
+    "mark",
+    "marquee",
+    "math",
+    "meter",
+    "menu",
+    "menubar",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "navigation",
+    "none",
+    "note",
+    "option",
+    "paragraph",
+    "presentation",
+    "progressbar",
+    "radio",
+    "radiogroup",
+    "region",
+    "row",
+    "rowgroup",
+    "rowheader",
+    "scrollbar",
+    "search",
+    "searchbox",
+    "separator",
+    "slider",
+    "spinbutton",
+    "status",
+    "strong",
+    "subscript",
+    "superscript",
+    "switch",
+    "tab",
+    "table",
+    "tablist",
+    "tabpanel",
+    "term",
+    "textbox",
+    "time",
+    "timer",
+    "toolbar",
+    "tooltip",
+    "tree",
+    "treegrid",
+    "treeitem",
+]);
+const ARIA_LEVEL_ROLES = new Set(["heading", "listitem", "row", "treeitem"]);
+export const ARIA_SELECTED_ROLES = new Set([
+    "gridcell",
+    "option",
+    "row",
+    "tab",
+    "rowheader",
+    "columnheader",
+    "treeitem",
+]);
+export const ARIA_CHECKED_ROLES = new Set([
+    "checkbox",
+    "radio",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "switch",
+]);
+export const ARIA_DISABLED_ROLES = new Set([
+    "application",
+    "button",
+    "composite",
+    "gridcell",
+    "group",
+    "input",
+    "link",
+    "menuitem",
+    "scrollbar",
+    "separator",
+    "tab",
+    "checkbox",
+    "columnheader",
+    "combobox",
+    "grid",
+    "listbox",
+    "menu",
+    "menubar",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "radiogroup",
+    "row",
+    "rowheader",
+    "searchbox",
+    "select",
+    "slider",
+    "spinbutton",
+    "switch",
+    "tablist",
+    "textbox",
+    "toolbar",
+    "tree",
+    "treegrid",
+    "treeitem",
+]);
+const NATIVE_HEADING_LEVELS = {
+    h1: 1,
+    h2: 2,
+    h3: 3,
+    h4: 4,
+    h5: 5,
+    h6: 6,
+};
+export function roleOf(element) {
+    const explicit = explicitRoleOf(element);
+    if (explicit === null) {
+        return _implicitRoleOf(element);
+    }
+    if (explicit === "presentation" || explicit === "none") {
+        return _implicitRoleOf(element);
+    }
+    return explicit;
+}
+export function explicitRoleOf(element) {
+    const tokens = (element.getAttribute("role") ?? "")
+        .split(" ")
+        .map((token) => token.trim().toLowerCase())
+        .filter((token) => token !== "");
+    return tokens.find((token) => VALID_ARIA_ROLES.has(token)) ?? null;
+}
+export function ariaLevelOf(element, role) {
+    if (!ARIA_LEVEL_ROLES.has(role)) {
+        return null;
+    }
+    if (role === "heading") {
+        const native = NATIVE_HEADING_LEVELS[element.tagName.toLowerCase()];
+        if (native !== undefined) {
+            return native;
+        }
+    }
+    const declared = Number(element.getAttribute("aria-level"));
+    return Number.isInteger(declared) && declared >= 1 ? declared : null;
+}
+export function ariaBooleanOf(attribute) {
+    if (attribute === null) {
+        return undefined;
+    }
+    return attribute.toLowerCase() === "true";
+}
+function _implicitRoleOf(element) {
+    const tag = element.tagName.toLowerCase();
+    if (isContentEditableElement(element)) {
+        return "textbox";
+    }
+    if (tag === "input") {
+        const type = element.getAttribute("type");
+        if (type === "submit" || type === "button" || type === "file") {
+            return "button";
+        }
+        if (type === "checkbox") {
+            return "checkbox";
+        }
+        if (type === "radio") {
+            return "radio";
+        }
+        return "textbox";
+    }
+    return IMPLICIT_ROLE_BY_TAG[tag] ?? "generic";
+}
+export function isContentEditableElement(element) {
+    if (element instanceof HTMLElement) {
+        const reflected = element.contentEditable;
+        if (reflected === "true" || reflected === "plaintext-only") {
+            return true;
+        }
+    }
+    const attribute = element.getAttribute("contenteditable");
+    return (attribute === "" || attribute === "true" || attribute === "plaintext-only");
+}

package/dist/reader/snapshot-compaction.d.ts

@@ -0,0 +1,5 @@
+import type { SnapshotNode } from "./snapshot.js";
+export declare function _mergeStringChildren(node: SnapshotNode): void;
+export declare function _unwrapBareGenerics(node: SnapshotNode, showHidden: boolean): void;
+export declare function _foldTextLeaves(node: SnapshotNode): void;
+export declare function _duplicateRefOf(node: SnapshotNode): string | null;