codex-autorunner 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

codex_autorunner/static/docChatRender.js

@@ -1,205 +0,0 @@
-import { flash, statusPill, isMobileViewport } from "./utils.js";
-import { chatUI } from "./docsElements.js";
-import { CHAT_HISTORY_LIMIT, getActiveDoc, getChatState, getDraft, isDraftPreview, setHistoryNavIndex, } from "./docsState.js";
-import { autoResizeTextarea, formatDraftTimestamp, renderDiffHtml, updateDocControls, updateDocVisibility, } from "./docsUi.js";
-import { renderChatEvents } from "./docChatEvents.js";
-export function updatePatchPreviewFromDraft(draft) {
-    if (!chatUI.patchBody || !draft || !draft.patch)
-        return;
-    chatUI.patchBody.innerHTML = renderDiffHtml(draft.patch);
-}
-export function renderChat() {
-    const state = getChatState();
-    const latest = state.history[0];
-    const isRunning = state.status === "running";
-    const hasError = !!state.error;
-    const pillState = isRunning
-        ? "running"
-        : state.status === "error"
-            ? "error"
-            : state.status === "interrupted"
-                ? "interrupted"
-                : "idle";
-    if (chatUI.status) {
-        statusPill(chatUI.status, pillState);
-    }
-    if (chatUI.send) {
-        chatUI.send.disabled = isRunning;
-    }
-    if (chatUI.input) {
-        chatUI.input.disabled = isRunning;
-    }
-    if (chatUI.cancel) {
-        chatUI.cancel.classList.toggle("hidden", !isRunning);
-    }
-    if (chatUI.voiceBtn) {
-        chatUI.voiceBtn.disabled =
-            isRunning && !chatUI.voiceBtn.classList.contains("voice-retry");
-        chatUI.voiceBtn.classList.toggle("disabled", chatUI.voiceBtn.disabled);
-        if (typeof chatUI.voiceBtn.setAttribute === "function") {
-            chatUI.voiceBtn.setAttribute("aria-disabled", chatUI.voiceBtn.disabled ? "true" : "false");
-        }
-    }
-    if (chatUI.newThread) {
-        chatUI.newThread.disabled = isRunning;
-        chatUI.newThread.classList.toggle("disabled", isRunning);
-    }
-    if (chatUI.hint) {
-        if (isRunning) {
-            const statusText = state.statusText || "processing";
-            chatUI.hint.textContent = statusText;
-            chatUI.hint.classList.add("loading");
-        }
-        else {
-            const sendHint = isMobileViewport()
-                ? "Tap Send to send · Enter for newline"
-                : "Cmd+Enter / Ctrl+Enter to send · Enter for newline";
-            chatUI.hint.textContent = sendHint;
-            chatUI.hint.classList.remove("loading");
-        }
-    }
-    if (hasError) {
-        chatUI.error.textContent = state.error;
-        chatUI.error.classList.remove("hidden");
-    }
-    else {
-        chatUI.error.textContent = "";
-        chatUI.error.classList.add("hidden");
-    }
-    const activeDoc = getActiveDoc();
-    const latestDrafts = latest?.drafts;
-    const draft = getDraft(activeDoc) || (latestDrafts?.[activeDoc] || null);
-    const hasPatch = !!(draft && (draft.patch || "").trim());
-    const previewing = hasPatch && isDraftPreview(activeDoc);
-    if (chatUI.patchMain) {
-        chatUI.patchMain.classList.toggle("hidden", !hasPatch);
-        chatUI.patchMain.classList.toggle("previewing", previewing);
-        chatUI.patchBody.innerHTML = hasPatch
-            ? renderDiffHtml(draft.patch)
-            : "(no draft)";
-        if (hasPatch) {
-            chatUI.patchSummary.textContent =
-                draft?.agentMessage ||
-                    latest?.response ||
-                    state.error ||
-                    "Draft ready";
-        }
-        else {
-            chatUI.patchSummary.textContent = "";
-        }
-        if (chatUI.patchMeta) {
-            const metaParts = [];
-            if (hasPatch && draft?.createdAt) {
-                metaParts.push(`drafted ${formatDraftTimestamp(draft.createdAt)}`);
-            }
-            if (hasPatch && draft?.baseHash) {
-                metaParts.push(`base ${draft.baseHash.slice(0, 7)}`);
-            }
-            chatUI.patchMeta.textContent = metaParts.join(" · ");
-        }
-        if (chatUI.patchApply)
-            chatUI.patchApply.disabled = isRunning || !hasPatch;
-        if (chatUI.patchDiscard)
-            chatUI.patchDiscard.disabled = isRunning || !hasPatch;
-        if (chatUI.patchReload)
-            chatUI.patchReload.disabled = isRunning;
-        if (chatUI.patchPreview) {
-            chatUI.patchPreview.disabled = isRunning || !hasPatch;
-            chatUI.patchPreview.textContent = previewing
-                ? "Hide preview"
-                : "Preview draft";
-            chatUI.patchPreview.classList.toggle("active", previewing);
-            chatUI.patchPreview.setAttribute("aria-pressed", previewing ? "true" : "false");
-        }
-    }
-    updateDocVisibility();
-    updateDocControls(activeDoc);
-    renderChatEvents(state);
-    renderChatHistory(state);
-}
-export function renderChatHistory(state) {
-    if (!chatUI.history)
-        return;
-    const count = state.history.length;
-    chatUI.historyCount.textContent = String(count);
-    chatUI.history.innerHTML = "";
-    if (count === 0) {
-        const empty = document.createElement("div");
-        empty.className = "doc-chat-empty";
-        empty.textContent = "No messages yet.";
-        chatUI.history.appendChild(empty);
-        return;
-    }
-    state.history.slice(0, CHAT_HISTORY_LIMIT).forEach((entry) => {
-        const wrapper = document.createElement("div");
-        wrapper.className = `doc-chat-entry ${entry.status}`;
-        const header = document.createElement("div");
-        header.className = "doc-chat-entry-header";
-        const promptRow = document.createElement("div");
-        promptRow.className = "prompt-row";
-        const prompt = document.createElement("div");
-        prompt.className = "prompt";
-        prompt.textContent = entry.prompt || "(no prompt)";
-        prompt.title = entry.prompt;
-        const copyBtn = document.createElement("button");
-        copyBtn.className = "copy-prompt-btn";
-        copyBtn.title = "Copy to input";
-        copyBtn.innerHTML = "↑";
-        copyBtn.addEventListener("click", (e) => {
-            e.stopPropagation();
-            if (chatUI.input)
-                chatUI.input.value = entry.prompt;
-            autoResizeTextarea(chatUI.input);
-            chatUI.input?.focus();
-            setHistoryNavIndex(-1);
-            flash("Prompt restored to input");
-        });
-        promptRow.appendChild(prompt);
-        promptRow.appendChild(copyBtn);
-        const meta = document.createElement("div");
-        meta.className = "meta";
-        const dot = document.createElement("span");
-        dot.className = "status-dot";
-        const stamp = document.createElement("span");
-        stamp.textContent = entry.time
-            ? new Date(entry.time).toLocaleTimeString([], {
-                hour: "2-digit",
-                minute: "2-digit",
-            })
-            : entry.status;
-        meta.appendChild(dot);
-        meta.appendChild(stamp);
-        header.appendChild(promptRow);
-        header.appendChild(meta);
-        const response = document.createElement("div");
-        response.className = "doc-chat-entry-response";
-        const isLatest = entry === state.history[0];
-        const runningText = (isLatest && state.streamText) ||
-            entry.response ||
-            (isLatest && state.statusText) ||
-            "queued";
-        const responseText = entry.error ||
-            (entry.status === "running" ? runningText : entry.response || "(no response)");
-        response.textContent = responseText;
-        response.classList.toggle("streaming", entry.status === "running" && !!(state.streamText || entry.response));
-        wrapper.appendChild(header);
-        wrapper.appendChild(response);
-        const tags = [];
-        if (entry.viewing) {
-            tags.push(`Viewing: ${entry.viewing.toUpperCase()}`);
-        }
-        else if (entry.targets && entry.targets.length) {
-            tags.push(`Targets: ${entry.targets.map((k) => k.toUpperCase()).join(", ")}`);
-        }
-        if (entry.updated && entry.updated.length) {
-            tags.push(`Drafts: ${entry.updated.map((k) => k.toUpperCase()).join(", ")}`);
-        }
-        if (tags.length) {
-            const tagLine = document.createElement("div");
-            tagLine.className = "doc-chat-entry-tags";
-            tagLine.textContent = tags.join(" · ");
-            wrapper.appendChild(tagLine);
-        }
-        chatUI.history.appendChild(wrapper);
-    });
-}

codex_autorunner/static/docChatStream.js

@@ -1,361 +0,0 @@
-import { resolvePath, getAuthToken } from "./utils.js";
-import { chatDecoder, getActiveDoc, getChatState, resetChatEvents, } from "./docsState.js";
-import { parseChatPayload, parseMaybeJson, recoverDraftMap, recoverPatchFromRaw, } from "./docsParse.js";
-import { applyDraftUpdates } from "./docsDrafts.js";
-import { renderChat, updatePatchPreviewFromDraft } from "./docChatRender.js";
-import { applyAppServerEvent, extractOutputDelta, renderChatEvents } from "./docChatEvents.js";
-import { getSelectedAgent, getSelectedModel, getSelectedReasoning, } from "./agentControls.js";
-export async function performDocChatRequest(entry, state) {
-    const endpoint = resolvePath("/api/docs/chat");
-    const headers = {
-        "Content-Type": "application/json",
-    };
-    const token = getAuthToken();
-    if (token) {
-        headers.Authorization = `Bearer ${token}`;
-    }
-    const payload = { message: entry.prompt, stream: true };
-    payload.agent = entry.agent || getSelectedAgent();
-    const selectedModel = entry.model || getSelectedModel(payload.agent);
-    const selectedReasoning = entry.reasoning || getSelectedReasoning(payload.agent);
-    if (selectedModel) {
-        payload.model = selectedModel;
-    }
-    if (selectedReasoning) {
-        payload.reasoning = selectedReasoning;
-    }
-    if (entry.viewing) {
-        payload.context_doc = entry.viewing;
-    }
-    const res = await fetch(endpoint, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(payload),
-        signal: state.controller.signal,
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        let detail = text;
-        try {
-            const parsed = JSON.parse(text);
-            const parsedObj = parsed;
-            detail = parsedObj.detail || parsedObj.error || text;
-        }
-        catch (err) {
-            // ignore parse errors
-        }
-        throw new Error(detail || `Request failed (${res.status})`);
-    }
-    const contentType = res.headers.get("content-type") || "";
-    if (contentType.includes("text/event-stream")) {
-        await readChatStream(res, state, entry);
-        if (entry.status !== "error" &&
-            entry.status !== "done" &&
-            entry.status !== "interrupted") {
-            entry.status = "done";
-        }
-    }
-    else {
-        const responsePayload = contentType.includes("application/json")
-            ? await res.json()
-            : await res.text();
-        applyChatResult(responsePayload, state, entry);
-    }
-}
-export async function startDocChatEventStream(payload) {
-    const threadId = payload?.thread_id || payload?.threadId;
-    const turnId = payload?.turn_id || payload?.turnId;
-    const agent = payload?.agent || getSelectedAgent();
-    if (!threadId || !turnId)
-        return;
-    const state = getChatState();
-    if (state.eventTurnId === turnId && state.eventThreadId === threadId) {
-        return;
-    }
-    resetChatEvents(state);
-    state.eventTurnId = turnId;
-    state.eventThreadId = threadId;
-    state.eventAgent = agent;
-    state.eventController = new AbortController();
-    renderChatEvents(state);
-    const endpoint = resolvePath(`/api/agents/${encodeURIComponent(agent)}/turns/${encodeURIComponent(turnId)}/events`);
-    const url = `${endpoint}?thread_id=${encodeURIComponent(threadId)}`;
-    const headers = {};
-    const token = getAuthToken();
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    try {
-        const res = await fetch(url, {
-            method: "GET",
-            headers,
-            signal: state.eventController.signal,
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(text || `Event stream failed (${res.status})`);
-        }
-        const contentType = res.headers.get("content-type") || "";
-        if (!contentType.includes("text/event-stream")) {
-            throw new Error("Event stream unavailable");
-        }
-        await readAppServerEventStream(res, state);
-    }
-    catch (err) {
-        const error = err;
-        if (error.name === "AbortError")
-            return;
-        state.eventError = error.message || "Failed to stream app-server events";
-        renderChatEvents(state);
-    }
-}
-export async function readAppServerEventStream(res, state) {
-    if (!res.body)
-        throw new Error("Streaming not supported in this browser");
-    const reader = res.body.getReader();
-    let buffer = "";
-    let escapedNewlines = false;
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        const decoded = chatDecoder.decode(value, { stream: true });
-        if (!escapedNewlines) {
-            const combined = buffer + decoded;
-            if (!combined.includes("\n") && combined.includes("\\n")) {
-                escapedNewlines = true;
-                buffer = buffer.replace(/\\n(?=event:|data:|\\n)/g, "\n");
-            }
-        }
-        buffer += escapedNewlines
-            ? decoded.replace(/\\n(?=event:|data:|\\n)/g, "\n")
-            : decoded;
-        const chunks = buffer.split("\n\n");
-        buffer = chunks.pop() || "";
-        for (const chunk of chunks) {
-            if (!chunk.trim())
-                continue;
-            let event = "message";
-            const dataLines = [];
-            chunk.split("\n").forEach((line) => {
-                if (line.startsWith("event:")) {
-                    event = line.slice(6).trim();
-                }
-                else if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trimStart());
-                }
-                else if (line.trim()) {
-                    dataLines.push(line);
-                }
-            });
-            if (dataLines.length === 0)
-                continue;
-            const data = dataLines.join("\n");
-            await handleAppServerStreamEvent(event || "message", data, state);
-        }
-    }
-}
-async function handleAppServerStreamEvent(_event, rawData, state) {
-    if (!rawData)
-        return;
-    const parsed = parseMaybeJson(rawData);
-    applyAppServerEvent(state, parsed);
-    const delta = extractOutputDelta(parsed);
-    if (delta) {
-        const entry = state.history[0];
-        if (entry && entry.status === "running") {
-            entry.response = (entry.response || "") + delta;
-            state.streamText = entry.response;
-            renderChat();
-        }
-    }
-    renderChatEvents(state);
-}
-export async function readChatStream(res, state, entry) {
-    if (!res.body)
-        throw new Error("Streaming not supported in this browser");
-    const reader = res.body.getReader();
-    let buffer = "";
-    let escapedNewlines = false;
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        const decoded = chatDecoder.decode(value, { stream: true });
-        if (!escapedNewlines) {
-            const combined = buffer + decoded;
-            if (!combined.includes("\n") && combined.includes("\\n")) {
-                escapedNewlines = true;
-                buffer = buffer.replace(/\\n(?=event:|data:|\\n)/g, "\n");
-            }
-        }
-        buffer += escapedNewlines
-            ? decoded.replace(/\\n(?=event:|data:|\\n)/g, "\n")
-            : decoded;
-        const chunks = buffer.split("\n\n");
-        buffer = chunks.pop() || "";
-        for (const chunk of chunks) {
-            if (!chunk.trim())
-                continue;
-            let event = "message";
-            const dataLines = [];
-            chunk.split("\n").forEach((line) => {
-                if (line.startsWith("event:")) {
-                    event = line.slice(6).trim();
-                }
-                else if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trimStart());
-                }
-                else if (line.trim()) {
-                    dataLines.push(line);
-                }
-            });
-            const data = dataLines.join("\n");
-            const sanitizedData = data.includes("\n")
-                ? data.replace(/\n/g, "\\n")
-                : data;
-            await handleStreamEvent(event || "message", sanitizedData, state, entry);
-        }
-    }
-}
-export async function handleStreamEvent(event, rawData, state, entry) {
-    const parsed = parseMaybeJson(rawData);
-    if (event === "turn") {
-        void startDocChatEventStream(parsed);
-        return;
-    }
-    if (event === "status") {
-        state.statusText =
-            typeof parsed === "string" ? parsed : parsed.status || "";
-        renderChat();
-        return;
-    }
-    if (event === "token") {
-        const token = typeof parsed === "string"
-            ? parsed
-            : parsed.token || parsed.text || rawData || "";
-        entry.response = (entry.response || "") + token;
-        state.streamText = entry.response || "";
-        if (!state.statusText || state.statusText === "queued") {
-            state.statusText = "responding";
-        }
-        renderChat();
-        return;
-    }
-    if (event === "update") {
-        const payload = parseChatPayload(parsed);
-        const fallbackPatch = recoverPatchFromRaw(rawData);
-        if (fallbackPatch) {
-            updatePatchPreviewFromDraft({
-                patch: fallbackPatch,
-                content: "",
-                agentMessage: "",
-                createdAt: "",
-                baseHash: "",
-            });
-        }
-        if (payload.response) {
-            entry.response = payload.response;
-        }
-        state.streamText = entry.response;
-        let updated = (payload.updated && payload.updated.length
-            ? payload.updated
-            : Object.keys(payload.drafts || {})) || [];
-        if (!updated.length) {
-            const recoveredDrafts = recoverDraftMap(rawData);
-            if (recoveredDrafts) {
-                updated = Object.keys(recoveredDrafts);
-                entry.updated = updated;
-                entry.drafts = recoveredDrafts;
-                applyDraftUpdates(recoveredDrafts);
-                updatePatchPreviewFromDraft(recoveredDrafts[getActiveDoc()]);
-                entry.status = "done";
-                renderChat();
-                return;
-            }
-            const recoveredPatch = recoverPatchFromRaw(rawData);
-            if (recoveredPatch) {
-                const recoveredDraft = {
-                    patch: recoveredPatch,
-                    content: "",
-                    agentMessage: "",
-                    createdAt: "",
-                    baseHash: "",
-                };
-                entry.updated = [getActiveDoc()];
-                entry.drafts = { [getActiveDoc()]: recoveredDraft };
-                applyDraftUpdates(entry.drafts);
-                updatePatchPreviewFromDraft(recoveredDraft);
-                entry.status = "done";
-                renderChat();
-                return;
-            }
-        }
-        if (updated.length) {
-            entry.updated = updated;
-            entry.drafts = payload.drafts || {};
-            applyDraftUpdates(payload.drafts);
-            updatePatchPreviewFromDraft(payload.drafts?.[getActiveDoc()]);
-            entry.status = "done";
-        }
-        renderChat();
-        return;
-    }
-    if (event === "error") {
-        const message = (parsed && parsed.detail) ||
-            (parsed && parsed.error) ||
-            rawData ||
-            "Doc chat failed";
-        entry.status = "error";
-        entry.error = String(message);
-        state.error = String(message);
-        state.status = "error";
-        renderChat();
-        resetChatEvents(state, { preserve: true });
-        throw new Error(String(message));
-    }
-    if (event === "interrupted") {
-        const message = (parsed && parsed.detail) || rawData || "Doc chat interrupted";
-        entry.status = "interrupted";
-        entry.error = String(message);
-        state.error = "";
-        state.status = "interrupted";
-        state.streamText = entry.response || "";
-        resetChatEvents(state, { preserve: true });
-        renderChat();
-        return;
-    }
-    if (event === "done" || event === "finish") {
-        entry.status = "done";
-        resetChatEvents(state, { preserve: true });
-        return;
-    }
-}
-export function applyChatResult(payload, state, entry) {
-    const parsed = parseChatPayload(payload);
-    if (parsed.interrupted) {
-        entry.status = "interrupted";
-        entry.error = parsed.detail || "Doc chat interrupted";
-        state.status = "interrupted";
-        state.error = "";
-        return;
-    }
-    if (parsed.error) {
-        entry.status = "error";
-        entry.error = parsed.error;
-        state.error = parsed.error;
-        state.status = "error";
-        renderChat();
-        return;
-    }
-    entry.status = "done";
-    entry.response = parsed.response || "(no response)";
-    state.streamText = parsed.response || "";
-    const updated = (parsed.updated && parsed.updated.length
-        ? parsed.updated
-        : Object.keys(parsed.drafts || {})) || [];
-    if (updated.length) {
-        entry.updated = updated;
-        entry.drafts = parsed.drafts || {};
-        applyDraftUpdates(parsed.drafts);
-    }
-}

codex_autorunner/static/docs.js

@@ -1,20 +0,0 @@
-import { initDocs } from "./docsInit.js";
-import { applyDocUpdateFromChat } from "./docsDocUpdates.js";
-import { applyPatch, discardPatch, reloadPatch } from "./docChatActions.js";
-import { getChatState } from "./docsState.js";
-import { handleStreamEvent, performDocChatRequest, applyChatResult } from "./docChatStream.js";
-import { renderChat } from "./docChatRender.js";
-import { setDoc } from "./docsCrud.js";
-export { initDocs };
-export const __docChatTest = {
-    applyChatResult,
-    applyDocUpdateFromChat,
-    applyPatch,
-    reloadPatch,
-    discardPatch,
-    getChatState,
-    handleStreamEvent,
-    performDocChatRequest,
-    renderChat,
-    setDoc,
-};

codex_autorunner/static/docsClipboard.js

@@ -1,69 +0,0 @@
-import { flash } from "./utils.js";
-import { PASTEABLE_DOCS, getActiveDoc, hasDraft, isDraftPreview } from "./docsState.js";
-import { getDocTextarea, getDocCopyText, updateDocControls } from "./docsUi.js";
-export async function copyDocToClipboard(kind = getActiveDoc()) {
-    const text = getDocCopyText(kind);
-    if (!text.trim())
-        return;
-    try {
-        if (navigator.clipboard?.writeText) {
-            await navigator.clipboard.writeText(text);
-            flash("Copied to clipboard");
-            return;
-        }
-    }
-    catch {
-        // fall through
-    }
-    let temp = null;
-    try {
-        temp = document.createElement("textarea");
-        temp.value = text;
-        temp.setAttribute("readonly", "");
-        temp.style.position = "fixed";
-        temp.style.top = "-9999px";
-        temp.style.opacity = "0";
-        document.body.appendChild(temp);
-        temp.select();
-        const ok = document.execCommand("copy");
-        flash(ok ? "Copied to clipboard" : "Copy failed");
-    }
-    catch {
-        flash("Copy failed");
-    }
-    finally {
-        if (temp && temp.parentNode) {
-            temp.parentNode.removeChild(temp);
-        }
-    }
-}
-export async function pasteSpecFromClipboard() {
-    const activeDoc = getActiveDoc();
-    if (!PASTEABLE_DOCS.includes(activeDoc))
-        return;
-    if (hasDraft(activeDoc) && isDraftPreview(activeDoc)) {
-        flash("Exit draft preview before pasting.", "error");
-        return;
-    }
-    const textarea = getDocTextarea();
-    if (!textarea)
-        return;
-    try {
-        if (!navigator.clipboard?.readText) {
-            flash("Paste not supported in this browser", "error");
-            return;
-        }
-        const text = await navigator.clipboard.readText();
-        if (!text) {
-            flash("Clipboard is empty", "error");
-            return;
-        }
-        textarea.value = text;
-        textarea.focus();
-        updateDocControls("spec");
-        flash("SPEC replaced from clipboard");
-    }
-    catch {
-        flash("Paste failed", "error");
-    }
-}