@teaflask/assistant 0.0.0 → 0.6.0

package/dist/reader/accessible-name.js

@@ -0,0 +1,248 @@
+import { roleOf } from "./roles.js";
+const MAX_NAME_DEPTH = 10;
+const MAX_NAME_LENGTH = 300;
+const NAME_FROM_CONTENT_ROLES = new Set([
+    "button",
+    "link",
+    "heading",
+    "cell",
+    "columnheader",
+    "rowheader",
+    "tooltip",
+    "tab",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "treeitem",
+    "option",
+    "listitem",
+    "row",
+    "term",
+]);
+const PROHIBITS_NAMING = new Set([
+    "caption",
+    "code",
+    "definition",
+    "deletion",
+    "emphasis",
+    "generic",
+    "insertion",
+    "mark",
+    "paragraph",
+    "presentation",
+    "strong",
+    "subscript",
+    "superscript",
+    "term",
+    "time",
+]);
+const NATIVELY_LABELABLE_TAGS = new Set([
+    "input",
+    "textarea",
+    "select",
+    "meter",
+    "progress",
+    "output",
+]);
+export function accessibleNameOf(element, probe, cache) {
+    const cached = cache.get(element);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let name = "";
+    if (!PROHIBITS_NAMING.has(roleOf(element))) {
+        name = _computedNameOf(element, probe, {
+            depth: 0,
+            visited: new Set(),
+            inLabelledBy: false,
+            inLabel: false,
+            inContent: false,
+        });
+    }
+    name = name.replace(/\s+/g, " ").trim().substring(0, MAX_NAME_LENGTH);
+    cache.set(element, name);
+    return name;
+}
+function _computedNameOf(element, probe, state) {
+    if (state.depth >= MAX_NAME_DEPTH || state.visited.has(element)) {
+        return "";
+    }
+    state.visited.add(element);
+    if (!state.inLabelledBy &&
+        !state.inLabel &&
+        _isHiddenForNaming(element, probe)) {
+        return "";
+    }
+    if (!state.inLabelledBy) {
+        const labelledBy = _labelledByNameOf(element, probe, state);
+        if (labelledBy !== "") {
+            return labelledBy;
+        }
+    }
+    const ariaLabel = (element.getAttribute("aria-label") ?? "").trim();
+    if (ariaLabel !== "") {
+        return ariaLabel;
+    }
+    if (NATIVELY_LABELABLE_TAGS.has(element.tagName.toLowerCase()) &&
+        !state.inLabel &&
+        !state.inLabelledBy) {
+        const fromLabels = _nativeLabelNameOf(element, probe, state);
+        if (fromLabels !== "") {
+            return fromLabels;
+        }
+    }
+    const alt = _altNameOf(element);
+    if (alt !== null) {
+        return alt;
+    }
+    const fromCaption = _captionNameOf(element, probe, state);
+    if (fromCaption !== "") {
+        return fromCaption;
+    }
+    if (element instanceof HTMLSelectElement && element.selectedIndex >= 0) {
+        const selected = element.options[element.selectedIndex];
+        const text = (selected?.textContent ?? "").trim();
+        if (text !== "") {
+            return text;
+        }
+    }
+    if (NAME_FROM_CONTENT_ROLES.has(roleOf(element)) ||
+        state.inLabelledBy ||
+        state.inLabel ||
+        state.inContent) {
+        const fromContent = _contentNameOf(element, probe, state);
+        if (fromContent !== "") {
+            return fromContent;
+        }
+    }
+    if (element instanceof HTMLInputElement &&
+        (element.type === "submit" || element.type === "button")) {
+        const value = element.value.trim();
+        if (value !== "") {
+            return value;
+        }
+    }
+    const placeholder = (element.getAttribute("placeholder") ?? "").trim();
+    if (placeholder !== "") {
+        return placeholder;
+    }
+    return (element.getAttribute("title") ?? "").trim();
+}
+function _labelledByNameOf(element, probe, state) {
+    const references = _idReferencesOf(element, element.getAttribute("aria-labelledby"));
+    const parts = references.map((reference) => _computedNameOf(reference, probe, {
+        depth: state.depth + 1,
+        visited: new Set(state.visited),
+        inLabelledBy: true,
+        inLabel: state.inLabel,
+        inContent: false,
+    }));
+    return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function _nativeLabelNameOf(element, probe, state) {
+    const parts = _labelsOf(element).map((label) => _computedNameOf(label, probe, {
+        depth: state.depth + 1,
+        visited: new Set(state.visited),
+        inLabelledBy: state.inLabelledBy,
+        inLabel: true,
+        inContent: false,
+    }));
+    return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function _altNameOf(element) {
+    const tag = element.tagName.toLowerCase();
+    const eligible = tag === "area" ||
+        tag === "img" ||
+        (tag === "input" && element.getAttribute("type") === "image");
+    if (!eligible) {
+        return null;
+    }
+    const alt = element.getAttribute("alt");
+    return alt === null ? null : alt.trim();
+}
+function _captionNameOf(element, probe, state) {
+    const tag = element.tagName.toLowerCase();
+    const captionSelector = tag === "fieldset"
+        ? ":scope > legend"
+        : tag === "figure"
+            ? ":scope > figcaption"
+            : tag === "table"
+                ? ":scope > caption"
+                : null;
+    if (captionSelector === null) {
+        return "";
+    }
+    const caption = element.querySelector(captionSelector);
+    if (caption === null) {
+        return "";
+    }
+    return _computedNameOf(caption, probe, {
+        depth: state.depth + 1,
+        visited: new Set(state.visited),
+        inLabelledBy: true,
+        inLabel: state.inLabel,
+        inContent: false,
+    });
+}
+function _contentNameOf(element, probe, state) {
+    const parts = [probe.pseudoContentOf(element, "::before")];
+    for (const child of Array.from(element.childNodes)) {
+        if (child.nodeType === Node.TEXT_NODE) {
+            parts.push(child.textContent ?? "");
+        }
+        else if (child.nodeType === Node.ELEMENT_NODE) {
+            parts.push(_computedNameOf(child, probe, {
+                depth: state.depth + 1,
+                visited: new Set(state.visited),
+                inLabelledBy: state.inLabelledBy,
+                inLabel: state.inLabel,
+                inContent: true,
+            }));
+        }
+    }
+    parts.push(probe.pseudoContentOf(element, "::after"));
+    return parts.join("").replace(/\s+/g, " ").trim();
+}
+function _isHiddenForNaming(element, probe) {
+    if (element.getAttribute("aria-hidden") === "true") {
+        return true;
+    }
+    const style = probe.styleOf(element);
+    return style.display === "none" || style.visibility === "hidden";
+}
+function _idReferencesOf(element, attributeValue) {
+    if (attributeValue === null || attributeValue === "") {
+        return [];
+    }
+    const documentOf = element.ownerDocument;
+    return attributeValue
+        .split(/\s+/)
+        .filter((id) => id !== "")
+        .map((id) => documentOf.getElementById(id))
+        .filter((referenced) => referenced !== null);
+}
+function _labelsOf(element) {
+    const labels = [];
+    const id = element.getAttribute("id");
+    if (id !== null && id !== "") {
+        labels.push(..._labelsWiredTo(element.ownerDocument, id));
+    }
+    for (let parent = element.parentElement; parent !== null; parent = parent.parentElement) {
+        if (parent.tagName.toLowerCase() === "label") {
+            if (!labels.includes(parent)) {
+                labels.push(parent);
+            }
+            break;
+        }
+    }
+    return labels;
+}
+function _labelsWiredTo(documentOf, id) {
+    const escaped = id.replace(/[\\"]/g, "\\$&");
+    try {
+        return Array.from(documentOf.querySelectorAll(`label[for="${escaped}"]`));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/reader/interactivity.d.ts

@@ -0,0 +1,11 @@
+import type { LayoutProbe } from "./layout-probe.js";
+export declare const INTERACTIVE_REF_ROLES: Set<string>;
+export declare const CONTENT_REF_ROLES: Set<string>;
+export interface InteractivitySignals {
+    interactive: boolean;
+    isInteractiveTag: boolean;
+    hints: string[];
+}
+export declare function interactivitySignalsOf(element: Element, probe: LayoutProbe): InteractivitySignals;
+export declare function isScrollable(element: Element, probe: LayoutProbe): boolean;
+export declare function isLandmark(element: Element): boolean;

package/dist/reader/interactivity.js

@@ -0,0 +1,117 @@
+import { explicitRoleOf, isContentEditableElement } from "./roles.js";
+const INTERACTIVE_TAGS = new Set([
+    "a",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "details",
+    "summary",
+]);
+export const INTERACTIVE_REF_ROLES = new Set([
+    "button",
+    "link",
+    "textbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "searchbox",
+    "slider",
+    "spinbutton",
+    "switch",
+    "tab",
+    "treeitem",
+]);
+export const CONTENT_REF_ROLES = new Set([
+    "cell",
+    "gridcell",
+    "columnheader",
+    "rowheader",
+    "listitem",
+    "article",
+    "region",
+    "main",
+    "navigation",
+]);
+const LANDMARK_TAGS = new Set([
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "nav",
+    "main",
+    "header",
+    "footer",
+    "section",
+    "article",
+    "aside",
+]);
+const SCROLLABLE_OVERFLOW_VALUES = new Set(["auto", "scroll", "overlay"]);
+export function interactivitySignalsOf(element, probe) {
+    const tag = element.tagName.toLowerCase();
+    const role = explicitRoleOf(element);
+    const tabIndex = element.getAttribute("tabindex");
+    const hasTabIndex = tabIndex !== null && tabIndex !== "-1";
+    const hasOnClick = element.hasAttribute("onclick");
+    const hasCursorPointer = probe.styleOf(element).cursor === "pointer";
+    const isInteractiveTag = INTERACTIVE_TAGS.has(tag);
+    const isRoleInteractive = role === "button" || role === "link";
+    const isContentEditable = isContentEditableElement(element);
+    let hasPointerInteraction = hasCursorPointer;
+    if (hasCursorPointer && !hasOnClick && !hasTabIndex) {
+        const parent = element.parentElement;
+        if (parent !== null && probe.styleOf(parent).cursor === "pointer") {
+            hasPointerInteraction = false;
+        }
+    }
+    const hints = [];
+    if (hasPointerInteraction) {
+        hints.push("cursor:pointer");
+    }
+    if (hasOnClick) {
+        hints.push("onclick");
+    }
+    if (hasTabIndex) {
+        hints.push("tabindex");
+    }
+    return {
+        interactive: isInteractiveTag ||
+            hasOnClick ||
+            hasTabIndex ||
+            isRoleInteractive ||
+            isContentEditable ||
+            hasPointerInteraction,
+        isInteractiveTag,
+        hints,
+    };
+}
+export function isScrollable(element, probe) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "html" || tag === "body") {
+        return false;
+    }
+    const style = probe.styleOf(element);
+    if (!SCROLLABLE_OVERFLOW_VALUES.has(style.overflowX) &&
+        !SCROLLABLE_OVERFLOW_VALUES.has(style.overflowY)) {
+        return false;
+    }
+    return (element.scrollHeight > element.clientHeight + 1 ||
+        element.scrollWidth > element.clientWidth + 1);
+}
+export function isLandmark(element) {
+    const tag = element.tagName.toLowerCase();
+    if (LANDMARK_TAGS.has(tag)) {
+        return true;
+    }
+    const explicitRole = explicitRoleOf(element);
+    return (explicitRole !== null &&
+        explicitRole !== "presentation" &&
+        explicitRole !== "none");
+}

package/dist/reader/layout-probe.d.ts

@@ -0,0 +1,29 @@
+export interface StyleSlice {
+    display: string;
+    visibility: string;
+    opacity: string;
+    cursor: string;
+    overflowX: string;
+    overflowY: string;
+}
+export interface RectSlice {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface SizeSlice {
+    width: number;
+    height: number;
+}
+export interface LayoutProbe {
+    styleOf(element: Element): StyleSlice;
+    pseudoContentOf(element: Element, pseudo: "::before" | "::after"): string;
+    rectOf(element: Element): RectSlice;
+    offsetSizeOf(element: Element): SizeSlice;
+    viewportSizeOf(): SizeSlice;
+    nativeVisibilityOf(element: Element): boolean | null;
+}
+export declare function browserLayoutProbe(): LayoutProbe;

package/dist/reader/layout-probe.js

@@ -0,0 +1,113 @@
+const DEFAULT_STYLE = {
+    display: "block",
+    visibility: "visible",
+    opacity: "1",
+    cursor: "auto",
+    overflowX: "visible",
+    overflowY: "visible",
+};
+const ZERO_RECT = {
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    width: 0,
+    height: 0,
+};
+export function browserLayoutProbe() {
+    return {
+        styleOf(element) {
+            try {
+                const style = window.getComputedStyle(element);
+                return {
+                    display: style.display,
+                    visibility: style.visibility,
+                    opacity: style.opacity,
+                    cursor: style.cursor,
+                    overflowX: style.overflowX,
+                    overflowY: style.overflowY,
+                };
+            }
+            catch {
+                return DEFAULT_STYLE;
+            }
+        },
+        pseudoContentOf(element, pseudo) {
+            try {
+                const style = window.getComputedStyle(element, pseudo);
+                if (style.display === "none" || style.visibility === "hidden") {
+                    return "";
+                }
+                return pseudoTextFromContentValue(style.content);
+            }
+            catch {
+                return "";
+            }
+        },
+        rectOf(element) {
+            try {
+                const rect = element.getBoundingClientRect();
+                return {
+                    top: rect.top,
+                    left: rect.left,
+                    right: rect.right,
+                    bottom: rect.bottom,
+                    width: rect.width,
+                    height: rect.height,
+                };
+            }
+            catch {
+                return ZERO_RECT;
+            }
+        },
+        offsetSizeOf(element) {
+            if (element instanceof HTMLElement) {
+                return { width: element.offsetWidth, height: element.offsetHeight };
+            }
+            return { width: -1, height: -1 };
+        },
+        viewportSizeOf() {
+            return { width: window.innerWidth, height: window.innerHeight };
+        },
+        nativeVisibilityOf(element) {
+            if (typeof element.checkVisibility !== "function") {
+                return null;
+            }
+            try {
+                return element.checkVisibility({
+                    checkOpacity: true,
+                    checkVisibilityCSS: true,
+                });
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+function pseudoTextFromContentValue(content) {
+    if (content === "" || content === "none" || content === "normal") {
+        return "";
+    }
+    const tokens = content.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g);
+    if (tokens === null) {
+        return "";
+    }
+    return tokens
+        .map((token) => _unescapedCssString(token.slice(1, -1)))
+        .join("");
+}
+function _unescapedCssString(text) {
+    return text.replace(/\\(.)/g, (_match, escaped) => {
+        if (escaped === "n") {
+            return "\n";
+        }
+        if (escaped === "r") {
+            return "\r";
+        }
+        if (escaped === "t") {
+            return "\t";
+        }
+        return escaped;
+    });
+}

package/dist/reader/line-diff.d.ts

@@ -0,0 +1 @@
+export declare function unifiedDiffOf(before: string, after: string): string;

package/dist/reader/line-diff.js

@@ -0,0 +1,147 @@
+const CONTEXT_LINES = 3;
+export function unifiedDiffOf(before, after) {
+    if (before === after) {
+        return "";
+    }
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const ops = _editOpsOf(beforeLines, afterLines);
+    return _hunksOf(ops).join("\n");
+}
+function _editOpsOf(before, after) {
+    const trace = _shortestEditTraceOf(before, after);
+    return _backtrackedOpsOf(trace, before, after);
+}
+function _shortestEditTraceOf(before, after) {
+    const n = before.length;
+    const m = after.length;
+    const max = n + m;
+    const offset = max;
+    const v = new Array(2 * max + 2).fill(0);
+    const trace = [];
+    for (let d = 0; d <= max; d += 1) {
+        trace.push(v.slice());
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) {
+                x = v[offset + k + 1];
+            }
+            else {
+                x = v[offset + k - 1] + 1;
+            }
+            let y = x - k;
+            while (x < n && y < m && before[x] === after[y]) {
+                x += 1;
+                y += 1;
+            }
+            v[offset + k] = x;
+            if (x >= n && y >= m) {
+                return trace;
+            }
+        }
+    }
+    return trace;
+}
+function _backtrackedOpsOf(trace, before, after) {
+    const offset = before.length + after.length;
+    const reversed = [];
+    let x = before.length;
+    let y = after.length;
+    for (let d = trace.length - 1; d >= 0 && (x > 0 || y > 0); d -= 1) {
+        const v = trace[d];
+        const k = x - y;
+        let previousK;
+        if (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) {
+            previousK = k + 1;
+        }
+        else {
+            previousK = k - 1;
+        }
+        const previousX = v[offset + previousK];
+        const previousY = previousX - previousK;
+        while (x > previousX && y > previousY) {
+            reversed.push({ tag: "equal", text: before[x - 1] });
+            x -= 1;
+            y -= 1;
+        }
+        if (d > 0) {
+            if (x === previousX) {
+                reversed.push({ tag: "insert", text: after[y - 1] });
+                y -= 1;
+            }
+            else {
+                reversed.push({ tag: "delete", text: before[x - 1] });
+                x -= 1;
+            }
+        }
+    }
+    return reversed.reverse();
+}
+function _hunksOf(ops) {
+    const groups = _changeGroupsOf(ops);
+    const lines = [];
+    let aLine = 1;
+    let bLine = 1;
+    let opIndex = 0;
+    for (const group of groups) {
+        while (opIndex < group.start) {
+            const op = ops[opIndex];
+            if (op.tag !== "insert") {
+                aLine += 1;
+            }
+            if (op.tag !== "delete") {
+                bLine += 1;
+            }
+            opIndex += 1;
+        }
+        let aCount = 0;
+        let bCount = 0;
+        const body = [];
+        for (let index = group.start; index < group.end; index += 1) {
+            const op = ops[index];
+            if (op.tag === "equal") {
+                body.push(` ${op.text}`);
+                aCount += 1;
+                bCount += 1;
+            }
+            else if (op.tag === "delete") {
+                body.push(`-${op.text}`);
+                aCount += 1;
+            }
+            else {
+                body.push(`+${op.text}`);
+                bCount += 1;
+            }
+        }
+        lines.push(`@@ -${String(aLine)},${String(aCount)} +${String(bLine)},${String(bCount)} @@`, ...body);
+        while (opIndex < group.end) {
+            const op = ops[opIndex];
+            if (op.tag !== "insert") {
+                aLine += 1;
+            }
+            if (op.tag !== "delete") {
+                bLine += 1;
+            }
+            opIndex += 1;
+        }
+    }
+    return lines;
+}
+function _changeGroupsOf(ops) {
+    const changeIndexes = ops
+        .map((op, index) => (op.tag === "equal" ? -1 : index))
+        .filter((index) => index >= 0);
+    const groups = [];
+    for (const changeIndex of changeIndexes) {
+        const start = Math.max(0, changeIndex - CONTEXT_LINES);
+        const end = Math.min(ops.length, changeIndex + CONTEXT_LINES + 1);
+        const last = groups[groups.length - 1];
+        if (last !== undefined && start <= last.end) {
+            last.end = Math.max(last.end, end);
+        }
+        else {
+            groups.push({ start, end });
+        }
+    }
+    return groups;
+}

package/dist/reader/read-page.d.ts

@@ -0,0 +1,12 @@
+import type { LayoutProbe } from "./layout-probe.js";
+export interface ReadPageReport {
+    url: string;
+    title: string;
+    content: string;
+    is_diff: boolean;
+    truncated: boolean;
+}
+export declare class SnapshotUnavailableError extends Error {
+}
+export declare function readPageResultOf(threadId: string, action: Record<string, unknown> | null, probe: LayoutProbe): ReadPageReport;
+export declare function _resetBaselinesForTests(): void;