codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/dom/message-format.js

@@ -0,0 +1,593 @@
+import { decodeBasicEntities, normalizeLineBreaks, normalizeWhitespace } from "./visible-text.js";
+const VOID_TAGS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+const SKIPPED_TAGS = new Set(["button", "nav", "script", "style", "svg"]);
+const BLOCK_TAGS = new Set([
+    "article",
+    "blockquote",
+    "div",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "tr",
+    "ul"
+]);
+export function normalizeResponseFormat(format) {
+    if (format === undefined || format === "markdown")
+        return "markdown";
+    if (format === "text")
+        return "normalized_text";
+    return format;
+}
+export function extractRoleMessageHtml(html) {
+    const root = parseHtmlFragment(html);
+    const messages = [];
+    walkElementsWithAncestors(root, [], (element, ancestors) => {
+        const role = element.attrs["data-message-author-role"];
+        if (role === "user" || role === "assistant") {
+            const metadataElement = [...ancestors]
+                .reverse()
+                .find(ancestor => ancestor.attrs["data-testid"]?.startsWith("conversation-turn")) ?? element;
+            messages.push({ role, html: serializeChildren(element), metadataHtml: serializeNode(metadataElement) });
+        }
+    });
+    return messages;
+}
+export function formatMessageHtml(html, requestedFormat = "markdown", maxChars, metadataHtml) {
+    const format = normalizeResponseFormat(requestedFormat);
+    const root = parseHtmlFragment(html);
+    const meaningfulChildren = stripIgnorableNodes(root.children);
+    const blocks = extractBlocks(meaningfulChildren);
+    const markdown = clamp(blocksToMarkdown(blocks), maxChars);
+    const visibleText = clamp(blocksToPlainText(blocks), maxChars);
+    const normalizedText = clamp(normalizeWhitespace(visibleText), maxChars);
+    const citations = collectCitations(meaningfulChildren);
+    const codeBlocks = blocks.flatMap(block => block.type === "code" ? [codeBlockFromBlock(block)] : []);
+    const tables = blocks.flatMap(block => block.type === "table" ? [tableFromBlock(block)] : []);
+    const metadata = extractResponseMetadata(metadataHtml ?? html);
+    const content = {
+        text: textForFormat(format, { markdown, visibleText, normalizedText, html }),
+        format,
+        source: "semantic_dom",
+        fidelity: fidelityForDomFormat(format)
+    };
+    const warnings = warningsForDomFormat(format);
+    if (warnings.length > 0)
+        content.warnings = warnings;
+    if (format === "markdown" || format === "all")
+        content.markdown = markdown;
+    if (format === "visible_text" || format === "all")
+        content.visibleText = visibleText;
+    if (format === "normalized_text" || format === "all")
+        content.normalizedText = normalizedText;
+    if (format === "html" || format === "all")
+        content.html = html;
+    if (format === "blocks" || format === "all")
+        content.blocks = blocks;
+    if ((format === "markdown" || format === "blocks" || format === "all") && citations.length > 0) {
+        content.citations = citations;
+    }
+    if ((format === "markdown" || format === "blocks" || format === "all") && codeBlocks.length > 0) {
+        content.codeBlocks = codeBlocks;
+    }
+    if ((format === "markdown" || format === "blocks" || format === "all") && tables.length > 0) {
+        content.tables = tables;
+    }
+    if (metadata.branch !== undefined)
+        content.branch = metadata.branch;
+    if (metadata.actions.length > 0)
+        content.actions = metadata.actions;
+    if (metadata.thoughtDurationText !== undefined)
+        content.thoughtDurationText = metadata.thoughtDurationText;
+    if (metadata.sourcesAvailable === true)
+        content.sourcesAvailable = true;
+    return content;
+}
+export function formatClipboardMarkdown(text, maxChars, requestedFormat = "markdown") {
+    const format = normalizeResponseFormat(requestedFormat);
+    const markdown = clamp(normalizeLineBreaks(text).trim(), maxChars);
+    const visibleText = markdown;
+    const normalizedText = clamp(normalizeWhitespace(markdown), maxChars);
+    const content = {
+        text: textForFormat(format, { markdown, visibleText, normalizedText, html: markdown }),
+        format,
+        source: "clipboard",
+        fidelity: "clipboard_markdown"
+    };
+    if (format === "markdown" || format === "all")
+        content.markdown = markdown;
+    if (format === "visible_text" || format === "all")
+        content.visibleText = visibleText;
+    if (format === "normalized_text" || format === "all")
+        content.normalizedText = normalizedText;
+    return content;
+}
+function fidelityForDomFormat(format) {
+    switch (format) {
+        case "markdown":
+            return "semantic_markdown";
+        case "visible_text":
+            return "visible_text";
+        case "normalized_text":
+            return "normalized_text";
+        case "html":
+            return "html";
+        case "blocks":
+            return "blocks";
+        case "all":
+            return "all";
+    }
+}
+function warningsForDomFormat(format) {
+    if (format !== "markdown" && format !== "all") {
+        return [];
+    }
+    return ["Markdown was reconstructed from visible DOM semantics; use response.copy for clipboard Markdown when exact copy fidelity is required."];
+}
+function textForFormat(format, values) {
+    switch (format) {
+        case "markdown":
+            return values.markdown;
+        case "visible_text":
+            return values.visibleText;
+        case "normalized_text":
+            return values.normalizedText;
+        case "html":
+            return values.normalizedText;
+        case "blocks":
+            return values.markdown;
+        case "all":
+            return values.markdown;
+    }
+}
+function parseHtmlFragment(html) {
+    const root = { type: "element", tag: "#root", attrs: {}, children: [] };
+    const stack = [root];
+    const tokenRe = /<!--[\s\S]*?-->|<![^>]*>|<\/?[a-zA-Z][^>]*>|[^<]+/g;
+    for (const match of html.matchAll(tokenRe)) {
+        const token = match[0];
+        const parent = stack.at(-1) ?? root;
+        if (token.startsWith("<!--") || token.startsWith("<!")) {
+            continue;
+        }
+        if (token.startsWith("</")) {
+            const tag = /^<\/\s*([a-zA-Z0-9-]+)/.exec(token)?.[1]?.toLowerCase();
+            if (tag === undefined)
+                continue;
+            while (stack.length > 1) {
+                const current = stack.pop();
+                if (current?.tag === tag)
+                    break;
+            }
+            continue;
+        }
+        if (token.startsWith("<")) {
+            const tag = /^<\s*([a-zA-Z0-9-]+)/.exec(token)?.[1]?.toLowerCase();
+            if (tag === undefined)
+                continue;
+            const element = {
+                type: "element",
+                tag,
+                attrs: parseAttrs(token),
+                children: []
+            };
+            parent.children.push(element);
+            if (!VOID_TAGS.has(tag) && !/\/\s*>$/.test(token)) {
+                stack.push(element);
+            }
+            continue;
+        }
+        parent.children.push({ type: "text", text: decodeBasicEntities(token) });
+    }
+    return root;
+}
+function parseAttrs(token) {
+    const attrs = {};
+    const attrText = token.replace(/^<\s*[^\s/>]+/, "").replace(/\/?>$/, "");
+    const attrRe = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+    for (const match of attrText.matchAll(attrRe)) {
+        const key = match[1]?.toLowerCase();
+        if (key === undefined)
+            continue;
+        attrs[key] = decodeBasicEntities(match[2] ?? match[3] ?? match[4] ?? "");
+    }
+    return attrs;
+}
+function walkElements(element, visit) {
+    visit(element);
+    for (const child of element.children) {
+        if (child.type === "element")
+            walkElements(child, visit);
+    }
+}
+function walkElementsWithAncestors(element, ancestors, visit) {
+    visit(element, ancestors);
+    for (const child of element.children) {
+        if (child.type === "element")
+            walkElementsWithAncestors(child, [...ancestors, element], visit);
+    }
+}
+function serializeChildren(element) {
+    return element.children.map(serializeNode).join("");
+}
+function serializeNode(node) {
+    if (node.type === "text")
+        return escapeHtml(node.text);
+    const attrs = Object.entries(node.attrs)
+        .map(([key, value]) => value.length > 0 ? ` ${key}="${escapeAttr(value)}"` : ` ${key}`)
+        .join("");
+    if (VOID_TAGS.has(node.tag))
+        return `<${node.tag}${attrs}>`;
+    return `<${node.tag}${attrs}>${serializeChildren(node)}</${node.tag}>`;
+}
+function stripIgnorableNodes(nodes) {
+    return nodes.filter(node => {
+        if (node.type === "text")
+            return node.text.trim().length > 0;
+        return !SKIPPED_TAGS.has(node.tag) && nodeText(node).trim().length > 0;
+    });
+}
+function extractBlocks(nodes) {
+    const blocks = [];
+    for (const node of nodes) {
+        if (node.type === "text") {
+            const text = normalizeWhitespace(node.text);
+            if (text.length > 0)
+                blocks.push({ type: "paragraph", text });
+            continue;
+        }
+        if (SKIPPED_TAGS.has(node.tag))
+            continue;
+        blocks.push(...elementToBlocks(node));
+    }
+    return blocks.filter(block => blockToPlainText(block).length > 0);
+}
+function elementToBlocks(element) {
+    if (/^h[1-6]$/.test(element.tag)) {
+        return [{ type: "heading", depth: Number(element.tag.slice(1)), text: inlineText(element.children) }];
+    }
+    if (element.tag === "p") {
+        return [{ type: "paragraph", text: inlineMarkdown(element.children) }];
+    }
+    if (element.tag === "ul" || element.tag === "ol") {
+        return [{
+                type: "list",
+                ordered: element.tag === "ol",
+                items: element.children
+                    .filter((child) => child.type === "element" && child.tag === "li")
+                    .map(item => markdownForListItem(item))
+                    .filter(Boolean)
+            }];
+    }
+    if (element.tag === "pre") {
+        const code = firstElement(element, "code") ?? element;
+        const language = languageFromClass(code.attrs.class);
+        const text = normalizeLineBreaks(nodeText(code)).replace(/^\n+|\n+$/g, "");
+        const block = language === undefined
+            ? { type: "code", text }
+            : { type: "code", language, text };
+        return [block];
+    }
+    if (element.tag === "table") {
+        return [tableBlock(element)];
+    }
+    if (element.tag === "blockquote") {
+        return [{ type: "quote", text: inlineMarkdown(element.children) }];
+    }
+    if (element.tag === "br") {
+        return [];
+    }
+    const childBlocks = extractBlocks(element.children);
+    if (childBlocks.length > 0 && hasBlockChild(element)) {
+        return childBlocks;
+    }
+    const text = inlineMarkdown(element.children);
+    return text.length > 0 ? [{ type: "paragraph", text }] : [];
+}
+function markdownForListItem(item) {
+    const childBlocks = extractBlocks(item.children);
+    if (childBlocks.length === 0)
+        return inlineMarkdown(item.children);
+    if (childBlocks.length === 1 && childBlocks[0]?.type === "paragraph")
+        return childBlocks[0].text;
+    return blocksToMarkdown(childBlocks);
+}
+function tableBlock(table) {
+    const rows = descendants(table, "tr")
+        .map(row => row.children.filter((child) => child.type === "element" && (child.tag === "th" || child.tag === "td")))
+        .filter(cells => cells.length > 0);
+    const firstHeaderRow = rows.find(cells => cells.some(cell => cell.tag === "th"));
+    const headers = (firstHeaderRow ?? rows[0] ?? []).map(cell => inlineText(cell.children));
+    const bodyRows = rows
+        .filter(cells => cells !== firstHeaderRow)
+        .map(cells => cells.map(cell => inlineText(cell.children)));
+    return { type: "table", headers, rows: bodyRows };
+}
+function inlineMarkdown(nodes) {
+    return normalizeInline(nodes.map(node => {
+        if (node.type === "text")
+            return node.text;
+        if (SKIPPED_TAGS.has(node.tag))
+            return "";
+        const child = inlineMarkdown(node.children);
+        switch (node.tag) {
+            case "a": {
+                const href = node.attrs.href;
+                if (href === undefined || href.length === 0)
+                    return child;
+                const label = child.length > 0 ? child : href;
+                return `[${escapeMarkdownLinkText(label)}](${href})`;
+            }
+            case "code":
+                return `\`${nodeText(node).trim()}\``;
+            case "strong":
+            case "b":
+                return child.length > 0 ? `**${child}**` : "";
+            case "em":
+            case "i":
+                return child.length > 0 ? `*${child}*` : "";
+            case "br":
+                return "\n";
+            default:
+                return child;
+        }
+    }).join(""));
+}
+function inlineText(nodes) {
+    return normalizeInline(nodes.map(node => {
+        if (node.type === "text")
+            return node.text;
+        if (SKIPPED_TAGS.has(node.tag))
+            return "";
+        if (node.tag === "br")
+            return "\n";
+        return inlineText(node.children);
+    }).join(""));
+}
+function blocksToMarkdown(blocks) {
+    return blocks.map(blockToMarkdown).filter(Boolean).join("\n\n").trim();
+}
+function blockToMarkdown(block) {
+    switch (block.type) {
+        case "heading":
+            return `${"#".repeat(Math.min(Math.max(block.depth, 1), 6))} ${block.text}`;
+        case "paragraph":
+            return block.text;
+        case "list":
+            return block.items.map((item, index) => block.ordered ? `${index + 1}. ${item}` : `- ${item}`).join("\n");
+        case "code":
+            return `\`\`\`${block.language ?? ""}\n${block.text}\n\`\`\``;
+        case "table":
+            return tableToMarkdown(block);
+        case "quote":
+            return block.text.split("\n").map(line => `> ${line}`).join("\n");
+        case "unknown":
+            return block.text;
+    }
+}
+function tableToMarkdown(table) {
+    const width = Math.max(table.headers.length, ...table.rows.map(row => row.length), 1);
+    const headers = padCells(table.headers, width);
+    const rows = table.rows.map(row => padCells(row, width));
+    return [
+        markdownTableRow(headers),
+        markdownTableRow(headers.map(() => "---")),
+        ...rows.map(markdownTableRow)
+    ].join("\n");
+}
+function markdownTableRow(cells) {
+    return `| ${cells.map(cell => cell.replace(/\|/g, "\\|")).join(" | ")} |`;
+}
+function padCells(cells, width) {
+    return Array.from({ length: width }, (_, index) => cells[index] ?? "");
+}
+function blocksToPlainText(blocks) {
+    return blocks.map(blockToPlainText).filter(Boolean).join("\n").trim();
+}
+function blockToPlainText(block) {
+    switch (block.type) {
+        case "heading":
+        case "paragraph":
+        case "quote":
+        case "unknown":
+            return inlineMarkdownToPlainText(block.text);
+        case "list":
+            return block.items.map(inlineMarkdownToPlainText).join("\n");
+        case "code":
+            return block.text;
+        case "table":
+            return [block.headers.join(" "), ...block.rows.map(row => row.join(" "))].join("\n");
+    }
+}
+function inlineMarkdownToPlainText(text) {
+    return normalizeWhitespace(text
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1"));
+}
+function collectCitations(nodes) {
+    const citations = [];
+    for (const node of nodes) {
+        if (node.type === "text" || SKIPPED_TAGS.has(node.tag))
+            continue;
+        if (node.tag === "a" && node.attrs.href !== undefined && node.attrs.href.length > 0) {
+            const text = inlineText(node.children) || node.attrs.href;
+            citations.push({ text, href: node.attrs.href });
+        }
+        citations.push(...collectCitations(node.children));
+    }
+    return citations;
+}
+function extractResponseMetadata(html) {
+    const root = parseHtmlFragment(html);
+    const text = normalizeWhitespace(metadataNodeText(root));
+    const actions = collectResponseActions(root);
+    const branch = extractBranchState(text, actions);
+    const thoughtDurationText = /\bThought for\s+[^.。!?]+?(?=(?:\s+\d+\s*\/\s*\d+)|\s+Sources\b|$)/i.exec(text)?.[0];
+    const sourcesAvailable = actions.some(action => action.type === "sources") || /\bSources\b/i.test(text);
+    return {
+        ...(branch === undefined ? {} : { branch }),
+        actions,
+        ...(thoughtDurationText === undefined ? {} : { thoughtDurationText }),
+        ...(sourcesAvailable ? { sourcesAvailable: true } : {})
+    };
+}
+function collectResponseActions(root) {
+    const actions = [];
+    walkElements(root, element => {
+        if (element.tag !== "button" && element.tag !== "div")
+            return;
+        const ariaLabel = element.attrs["aria-label"];
+        const text = inlineText(element.children);
+        const label = normalizeWhitespace(ariaLabel ?? text);
+        const type = responseActionType(label);
+        if (type === undefined)
+            return;
+        const action = { type, label };
+        if (ariaLabel !== undefined)
+            action.ariaLabel = ariaLabel;
+        if (text.length > 0)
+            action.text = text;
+        if (element.attrs["data-testid"] !== undefined)
+            action.testId = element.attrs["data-testid"];
+        if (element.attrs.disabled !== undefined || element.attrs["aria-disabled"] === "true")
+            action.disabled = true;
+        actions.push(action);
+    });
+    return dedupeActions(actions);
+}
+function responseActionType(label) {
+    if (/^previous response$/i.test(label))
+        return "previous_response";
+    if (/^next response$/i.test(label))
+        return "next_response";
+    if (/^copy response$/i.test(label))
+        return "copy_response";
+    if (/^sources$/i.test(label) || /\bSources\b/.test(label))
+        return "sources";
+    if (/^good response$/i.test(label))
+        return "good_response";
+    if (/^bad response$/i.test(label))
+        return "bad_response";
+    if (/^more actions$/i.test(label))
+        return "more_actions";
+    return undefined;
+}
+function dedupeActions(actions) {
+    const seen = new Set();
+    const unique = [];
+    for (const action of actions) {
+        const key = `${action.type}:${action.label}:${action.testId ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(action);
+    }
+    return unique;
+}
+function extractBranchState(text, actions) {
+    const match = /\b(\d+)\s*\/\s*(\d+)\b/.exec(text);
+    if (match === null)
+        return undefined;
+    const current = Number(match[1]);
+    const total = Number(match[2]);
+    const branch = { label: match[0] };
+    if (Number.isFinite(current))
+        branch.current = current;
+    if (Number.isFinite(total))
+        branch.total = total;
+    const previous = actions.find(action => action.type === "previous_response");
+    const next = actions.find(action => action.type === "next_response");
+    if (previous !== undefined)
+        branch.canGoPrevious = previous.disabled !== true;
+    if (next !== undefined)
+        branch.canGoNext = next.disabled !== true;
+    return branch;
+}
+function codeBlockFromBlock(block) {
+    return block.language === undefined ? { text: block.text } : { language: block.language, text: block.text };
+}
+function tableFromBlock(block) {
+    return { headers: block.headers, rows: block.rows };
+}
+function firstElement(element, tag) {
+    for (const child of element.children) {
+        if (child.type === "element") {
+            if (child.tag === tag)
+                return child;
+            const nested = firstElement(child, tag);
+            if (nested !== undefined)
+                return nested;
+        }
+    }
+    return undefined;
+}
+function descendants(element, tag) {
+    const found = [];
+    walkElements(element, child => {
+        if (child.tag === tag)
+            found.push(child);
+    });
+    return found;
+}
+function hasBlockChild(element) {
+    return element.children.some(child => child.type === "element" && BLOCK_TAGS.has(child.tag));
+}
+function nodeText(node) {
+    if (node.type === "text")
+        return node.text;
+    if (SKIPPED_TAGS.has(node.tag))
+        return "";
+    if (node.tag === "br")
+        return "\n";
+    return node.children.map(nodeText).join("");
+}
+function metadataNodeText(node) {
+    if (node.type === "text")
+        return node.text;
+    if (node.tag === "script" || node.tag === "style" || node.tag === "svg")
+        return "";
+    if (node.tag === "br")
+        return "\n";
+    return node.children.map(metadataNodeText).join(" ");
+}
+function languageFromClass(className) {
+    return className?.split(/\s+/).find(name => name.startsWith("language-"))?.slice("language-".length);
+}
+function normalizeInline(text) {
+    return decodeBasicEntities(text)
+        .replace(/[ \t\r\n]+/g, " ")
+        .replace(/\s+([.,;:!?])/g, "$1")
+        .trim();
+}
+function clamp(text, maxChars) {
+    if (maxChars === undefined || text.length <= maxChars)
+        return text;
+    return text.slice(0, Math.max(0, maxChars));
+}
+function escapeMarkdownLinkText(text) {
+    return text.replace(/]/g, "\\]");
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function escapeAttr(text) {
+    return escapeHtml(text).replace(/"/g, "&quot;");
+}

package/dist/src/dom/messages.d.ts

@@ -0,0 +1,40 @@
+import type { PageLike, ResponseAction, ResponseBlock, ResponseBranchState, ResponseCaptureFidelity, ResponseCaptureSource, ResponseCitation, ResponseCodeBlock, ResponseFormat, ResponseTable } from "../types.js";
+export type MessageRole = "user" | "assistant";
+export type ExtractedMessage = {
+    role: MessageRole;
+    text: string;
+    format: Exclude<ResponseFormat, "text">;
+    source?: ResponseCaptureSource;
+    fidelity?: ResponseCaptureFidelity;
+    warnings?: string[];
+    markdown?: string;
+    visibleText?: string;
+    normalizedText?: string;
+    html?: string;
+    blocks?: ResponseBlock[];
+    citations?: ResponseCitation[];
+    codeBlocks?: ResponseCodeBlock[];
+    tables?: ResponseTable[];
+    branch?: ResponseBranchState;
+    actions?: ResponseAction[];
+    thoughtDurationText?: string;
+    sourcesAvailable?: boolean;
+};
+export type ReadMessagesArgs = {
+    role?: MessageRole;
+    scope?: "visible" | "loaded";
+    format?: ResponseFormat;
+    maxChars?: number;
+};
+export type LatestMessageTextSnapshot = {
+    latestText?: string;
+    turnCount: number;
+};
+export declare function extractMessagesFromHtml(html: string, args?: ReadMessagesArgs): ExtractedMessage[];
+export declare function readMessages(page: PageLike, args?: ReadMessagesArgs): Promise<ExtractedMessage[]>;
+export declare function readLatestMessage(page: PageLike, role?: MessageRole, format?: ResponseFormat, maxChars?: number): Promise<ExtractedMessage | undefined>;
+export declare function readLatestMessageText(page: PageLike, role?: MessageRole): Promise<string | undefined>;
+export declare function readLatestMessageTextSnapshot(page: PageLike, role: MessageRole): Promise<LatestMessageTextSnapshot>;
+export declare function isTransientAssistantText(text: string): boolean;
+export declare function countMessages(messages: ExtractedMessage[], role?: MessageRole): number;
+export declare function countPageMessages(page: PageLike, role?: MessageRole): Promise<number>;