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

codex_autorunner/static/docChatCore.js

@@ -0,0 +1,324 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { parseAppServerEvent } from "./agentEvents.js";
+import { summarizeEvents, renderCompactSummary, COMPACT_MAX_ACTIONS, COMPACT_MAX_TEXT_LENGTH } from "./eventSummarizer.js";
+import { saveChatHistory, loadChatHistory } from "./docChatStorage.js";
+function getElements(prefix) {
+    return {
+        input: document.getElementById(`${prefix}-input`),
+        sendBtn: document.getElementById(`${prefix}-send`),
+        voiceBtn: document.getElementById(`${prefix}-voice`),
+        cancelBtn: document.getElementById(`${prefix}-cancel`),
+        newThreadBtn: document.getElementById(`${prefix}-new-thread`),
+        statusEl: document.getElementById(`${prefix}-status`),
+        errorEl: document.getElementById(`${prefix}-error`),
+        streamEl: document.getElementById(`${prefix}-stream`),
+        eventsMain: document.getElementById(`${prefix}-events`),
+        eventsList: document.getElementById(`${prefix}-events-list`),
+        eventsCount: document.getElementById(`${prefix}-events-count`),
+        eventsToggle: document.getElementById(`${prefix}-events-toggle`),
+        messagesEl: document.getElementById(`${prefix}-messages`) ||
+            document.getElementById(`${prefix}-history`),
+        historyHeader: document.getElementById(`${prefix}-history-header`),
+        voiceStatus: document.getElementById(`${prefix}-voice-status`),
+    };
+}
+function addEvent(state, entry, limits) {
+    state.events.push(entry);
+    if (state.events.length > limits.eventMax) {
+        state.events = state.events.slice(-limits.eventMax);
+        state.eventItemIndex = {};
+        state.events.forEach((evt, idx) => {
+            if (evt.itemId)
+                state.eventItemIndex[evt.itemId] = idx;
+        });
+    }
+}
+function buildMessage(role, content, isFinal) {
+    return {
+        id: `${role}-${Date.now()}`,
+        role,
+        content,
+        time: new Date().toISOString(),
+        isFinal,
+    };
+}
+export function createDocChat(config) {
+    const state = {
+        status: "idle",
+        target: null,
+        error: "",
+        streamText: "",
+        statusText: "",
+        controller: null,
+        draft: null,
+        events: [],
+        messages: [],
+        eventItemIndex: {},
+        eventsExpanded: false,
+    };
+    const elements = getElements(config.idPrefix);
+    function saveHistory() {
+        if (!config.storage || !state.target)
+            return;
+        saveChatHistory(config.storage, state.target, state.messages);
+    }
+    function loadHistory() {
+        if (!config.storage || !state.target) {
+            state.messages = [];
+            return;
+        }
+        state.messages = loadChatHistory(config.storage, state.target);
+    }
+    function setTarget(target) {
+        state.target = target;
+        loadHistory();
+        clearEvents();
+        render();
+    }
+    function addUserMessage(content) {
+        state.messages.push(buildMessage("user", content, true));
+        saveHistory();
+    }
+    function addAssistantMessage(content, isFinal = true) {
+        if (!content)
+            return;
+        const last = state.messages[state.messages.length - 1];
+        if (last && last.role === "assistant" && last.content === content)
+            return;
+        state.messages.push(buildMessage("assistant", content, isFinal));
+        saveHistory();
+    }
+    function clearEvents() {
+        state.events = [];
+        state.eventItemIndex = {};
+    }
+    function applyAppEvent(payload) {
+        const parsed = parseAppServerEvent(payload);
+        if (!parsed)
+            return;
+        const { event, mergeStrategy } = parsed;
+        const itemId = event.itemId;
+        if (mergeStrategy && itemId && state.eventItemIndex[itemId] !== undefined) {
+            const existingIndex = state.eventItemIndex[itemId];
+            const existing = state.events[existingIndex];
+            if (mergeStrategy === "append") {
+                existing.summary = `${existing.summary || ""}${event.summary}`;
+            }
+            else if (mergeStrategy === "newline") {
+                existing.summary = `${existing.summary || ""}\n\n`;
+            }
+            existing.time = event.time;
+            return;
+        }
+        addEvent(state, { ...event }, config.limits);
+        if (itemId)
+            state.eventItemIndex[itemId] = state.events.length - 1;
+    }
+    function renderEvents() {
+        const { eventsMain, eventsList, eventsCount, eventsToggle } = elements;
+        if (!eventsMain || !eventsList || !eventsCount)
+            return;
+        const hasEvents = state.events.length > 0;
+        const isRunning = state.status === "running";
+        const showEvents = hasEvents || isRunning;
+        const compactMode = !!config.compactMode;
+        const expanded = !!state.eventsExpanded;
+        if (config.styling.eventsHiddenClass) {
+            eventsMain.classList.toggle(config.styling.eventsHiddenClass, !showEvents);
+        }
+        else {
+            eventsMain.classList.toggle("hidden", !showEvents);
+        }
+        eventsCount.textContent = String(state.events.length);
+        if (!showEvents) {
+            eventsList.innerHTML = "";
+            return;
+        }
+        if (compactMode && !expanded) {
+            renderCompactEvents();
+            if (eventsToggle) {
+                eventsToggle.classList.toggle("hidden", !hasEvents);
+                eventsToggle.textContent = "Show details";
+            }
+            return;
+        }
+        const limit = config.limits.eventVisible;
+        const showCount = compactMode ? state.events.length : expanded ? state.events.length : Math.min(state.events.length, limit);
+        const visible = state.events.slice(-showCount);
+        if (eventsToggle) {
+            if (compactMode) {
+                eventsToggle.classList.toggle("hidden", !hasEvents);
+                eventsToggle.textContent = "Show compact";
+            }
+            else {
+                const hiddenCount = Math.max(0, state.events.length - showCount);
+                eventsToggle.classList.toggle("hidden", hiddenCount === 0);
+                eventsToggle.textContent = expanded ? "Show recent" : `Show more (${hiddenCount})`;
+            }
+        }
+        eventsList.innerHTML = "";
+        if (!hasEvents && isRunning) {
+            const empty = document.createElement("div");
+            empty.className =
+                config.styling.eventsWaitingClass || config.styling.eventsEmptyClass || "chat-events-empty";
+            empty.textContent = "Processing...";
+            eventsList.appendChild(empty);
+            return;
+        }
+        visible.forEach((entry) => {
+            const wrapper = document.createElement("div");
+            wrapper.className = `${config.styling.eventClass} ${entry.kind || ""}`.trim();
+            const title = document.createElement("div");
+            title.className = config.styling.eventTitleClass;
+            title.textContent = entry.title || entry.method || "Update";
+            wrapper.appendChild(title);
+            if (entry.summary) {
+                const summary = document.createElement("div");
+                summary.className = config.styling.eventSummaryClass;
+                summary.textContent = entry.summary;
+                wrapper.appendChild(summary);
+            }
+            if (entry.detail) {
+                const detail = document.createElement("div");
+                detail.className = config.styling.eventDetailClass;
+                detail.textContent = entry.detail;
+                wrapper.appendChild(detail);
+            }
+            const meta = document.createElement("div");
+            meta.className = config.styling.eventMetaClass;
+            meta.textContent = entry.time
+                ? new Date(entry.time).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })
+                : "";
+            wrapper.appendChild(meta);
+            eventsList.appendChild(wrapper);
+        });
+        eventsList.scrollTop = eventsList.scrollHeight;
+    }
+    function renderCompactEvents() {
+        const { eventsList } = elements;
+        if (!eventsList)
+            return;
+        eventsList.innerHTML = "";
+        const summary = summarizeEvents(state.events, {
+            maxActions: config.compactOptions?.maxActions ?? COMPACT_MAX_ACTIONS,
+            maxTextLength: config.compactOptions?.maxTextLength ?? COMPACT_MAX_TEXT_LENGTH,
+        });
+        const text = state.events.length ? renderCompactSummary(summary) : "";
+        const wrapper = document.createElement("pre");
+        wrapper.className = "chat-events-compact";
+        wrapper.textContent = text || (state.status === "running" ? "Processing..." : "No events yet.");
+        eventsList.appendChild(wrapper);
+    }
+    function renderMessages() {
+        const { messagesEl, historyHeader } = elements;
+        if (!messagesEl)
+            return;
+        messagesEl.innerHTML = "";
+        const hasMessages = state.messages.length > 0;
+        const hasStream = !!state.streamText;
+        if (historyHeader) {
+            historyHeader.classList.toggle("hidden", !(hasMessages || hasStream));
+        }
+        messagesEl.classList.toggle("chat-history-empty", !(hasMessages || hasStream));
+        if (!hasMessages && !hasStream) {
+            return;
+        }
+        state.messages.forEach((msg) => {
+            const wrapper = document.createElement("div");
+            const roleClass = msg.role === "user" ? config.styling.messageUserClass : config.styling.messageAssistantClass;
+            const finalClass = msg.role === "assistant"
+                ? (msg.isFinal ? config.styling.messageAssistantFinalClass : config.styling.messageAssistantThinkingClass)
+                : "";
+            wrapper.className = [config.styling.messagesClass, roleClass, finalClass].filter(Boolean).join(" ").trim();
+            const roleLabel = document.createElement("div");
+            roleLabel.className = config.styling.messageRoleClass;
+            if (msg.role === "user") {
+                roleLabel.textContent = "You";
+            }
+            else {
+                roleLabel.textContent = msg.isFinal ? "Response" : "Thinking";
+            }
+            wrapper.appendChild(roleLabel);
+            const content = document.createElement("div");
+            content.className = config.styling.messageContentClass;
+            content.textContent = msg.content;
+            wrapper.appendChild(content);
+            const meta = document.createElement("div");
+            meta.className = config.styling.messageMetaClass;
+            const time = msg.time ? new Date(msg.time) : new Date();
+            meta.textContent = time.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            wrapper.appendChild(meta);
+            messagesEl.appendChild(wrapper);
+        });
+        if (hasStream) {
+            const streaming = document.createElement("div");
+            streaming.className = [
+                config.styling.messagesClass,
+                config.styling.messageAssistantClass,
+                config.styling.messageAssistantThinkingClass || "",
+            ]
+                .filter(Boolean)
+                .join(" ")
+                .trim();
+            const roleLabel = document.createElement("div");
+            roleLabel.className = config.styling.messageRoleClass;
+            roleLabel.textContent = "Thinking";
+            streaming.appendChild(roleLabel);
+            const content = document.createElement("div");
+            content.className = config.styling.messageContentClass;
+            content.textContent = state.streamText;
+            streaming.appendChild(content);
+            messagesEl.appendChild(streaming);
+        }
+        messagesEl.scrollTop = messagesEl.scrollHeight;
+    }
+    function render() {
+        const { statusEl, errorEl, cancelBtn, newThreadBtn, streamEl, } = elements;
+        if (statusEl) {
+            const status = state.error ? "error" : state.statusText || state.status;
+            statusEl.textContent = status;
+            statusEl.classList.toggle("error", !!state.error || state.status === "error");
+            statusEl.classList.toggle("running", state.status === "running");
+        }
+        if (errorEl) {
+            errorEl.textContent = state.error || "";
+            errorEl.classList.toggle("hidden", !state.error);
+        }
+        if (cancelBtn) {
+            cancelBtn.classList.toggle("hidden", state.status !== "running");
+        }
+        if (newThreadBtn) {
+            const hasHistory = state.messages.length > 0;
+            newThreadBtn.classList.toggle("hidden", !hasHistory || state.status === "running");
+        }
+        if (streamEl) {
+            const hasContent = state.events.length > 0 ||
+                state.messages.length > 0 ||
+                !!state.streamText ||
+                state.status === "running";
+            streamEl.classList.toggle("hidden", !hasContent);
+        }
+        renderEvents();
+        renderMessages();
+    }
+    // wire toggle
+    if (elements.eventsToggle) {
+        elements.eventsToggle.addEventListener("click", () => {
+            state.eventsExpanded = !state.eventsExpanded;
+            renderEvents();
+        });
+    }
+    return {
+        state,
+        elements,
+        render,
+        renderMessages,
+        renderEvents,
+        renderCompactEvents,
+        clearEvents,
+        applyAppEvent,
+        addUserMessage,
+        addAssistantMessage,
+        setTarget,
+    };
+}

codex_autorunner/static/docChatStorage.js

@@ -0,0 +1,65 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+const DEFAULT_VERSION = 1;
+function buildKey(config, target) {
+    return `${config.keyPrefix}${target}`;
+}
+export function saveChatHistory(config, target, messages) {
+    const key = buildKey(config, target);
+    const data = {
+        version: config.version ?? DEFAULT_VERSION,
+        target,
+        messages: messages.slice(-(config.maxMessages || 50)),
+        lastUpdated: new Date().toISOString(),
+    };
+    try {
+        localStorage.setItem(key, JSON.stringify(data));
+    }
+    catch (err) {
+        console.warn("localStorage quota exceeded, clearing old chat history", err);
+        clearOldChatHistory(config);
+        try {
+            localStorage.setItem(key, JSON.stringify(data));
+        }
+        catch (err2) {
+            console.error("Failed to save chat history after cleanup", err2);
+        }
+    }
+}
+export function loadChatHistory(config, target) {
+    const key = buildKey(config, target);
+    try {
+        const raw = localStorage.getItem(key);
+        if (!raw)
+            return [];
+        const data = JSON.parse(raw);
+        const version = config.version ?? DEFAULT_VERSION;
+        if (data.version !== version)
+            return [];
+        return data.messages || [];
+    }
+    catch {
+        return [];
+    }
+}
+export function clearChatHistory(config, target) {
+    localStorage.removeItem(buildKey(config, target));
+}
+function clearOldChatHistory(config) {
+    const entries = [];
+    for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(config.keyPrefix)) {
+            try {
+                const data = JSON.parse(localStorage.getItem(key) || "{}");
+                entries.push({ key, lastUpdated: data.lastUpdated || "" });
+            }
+            catch {
+                // ignore parse errors
+            }
+        }
+    }
+    entries
+        .sort((a, b) => a.lastUpdated.localeCompare(b.lastUpdated))
+        .slice(0, Math.ceil(entries.length / 2))
+        .forEach((entry) => localStorage.removeItem(entry.key));
+}

codex_autorunner/static/docChatVoice.js

@@ -0,0 +1,65 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+/**
+ * Generic voice helper for doc/ticket chats.
+ */
+import { flash } from "./utils.js";
+import { initVoiceInput } from "./voice.js";
+const VOICE_TRANSCRIPT_DISCLAIMER_TEXT = "Note: the text above was transcribed from voice input and may contain transcription errors.";
+function wrapInjectedContext(text) {
+    return `<injected context>\n${text}\n</injected context>`;
+}
+function appendVoiceTranscriptDisclaimer(text) {
+    const base = text === undefined || text === null ? "" : String(text);
+    if (!base.trim())
+        return base;
+    const injection = wrapInjectedContext(VOICE_TRANSCRIPT_DISCLAIMER_TEXT);
+    if (base.includes(VOICE_TRANSCRIPT_DISCLAIMER_TEXT) || base.includes(injection)) {
+        return base;
+    }
+    const separator = base.endsWith("\n") ? "\n" : "\n\n";
+    return `${base}${separator}${injection}`;
+}
+function autoResizeTextarea(textarea) {
+    textarea.style.height = "auto";
+    textarea.style.height = Math.min(textarea.scrollHeight, 100) + "px";
+}
+export async function initDocChatVoice(config) {
+    const voiceBtn = document.getElementById(config.buttonId);
+    const input = document.getElementById(config.inputId);
+    const statusEl = config.statusId
+        ? document.getElementById(config.statusId)
+        : null;
+    if (!voiceBtn || !input)
+        return;
+    await initVoiceInput({
+        button: voiceBtn,
+        input,
+        statusEl: statusEl ?? undefined,
+        onTranscript: (text) => {
+            if (!text) {
+                flash("Voice capture returned no transcript", "error");
+                return;
+            }
+            const current = input.value.trim();
+            const prefix = current ? `${current} ` : "";
+            let next = `${prefix}${text}`.trim();
+            next = appendVoiceTranscriptDisclaimer(next);
+            input.value = next;
+            autoResizeTextarea(input);
+            input.focus();
+            flash("Voice transcript added");
+        },
+        onError: (msg) => {
+            if (msg) {
+                flash(msg, "error");
+                if (statusEl) {
+                    statusEl.textContent = msg;
+                    statusEl.classList.remove("hidden");
+                }
+            }
+        },
+    }).catch((err) => {
+        console.error("Voice init failed", err);
+        flash("Voice capture unavailable", "error");
+    });
+}

codex_autorunner/static/docEditor.js

@@ -0,0 +1,133 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+export class DocEditor {
+    constructor(config) {
+        this.saveTimer = null;
+        this.lastSavedContent = "";
+        this.status = "idle";
+        this.destroyed = false;
+        this.handleKeydown = (evt) => {
+            const active = document.activeElement;
+            const isTextarea = active === this.config.textarea;
+            if (!isTextarea)
+                return;
+            if ((evt.metaKey || evt.ctrlKey) && evt.key.toLowerCase() === "s") {
+                evt.preventDefault();
+                void this.save(true);
+            }
+        };
+        this.handleBeforeUnload = (evt) => {
+            if (this.status === "dirty" || this.status === "saving") {
+                evt.preventDefault();
+                evt.returnValue = "Unsaved changes";
+            }
+        };
+        const { autoSaveDelay = 2000, enableKeyboardSave = true, saveButton = null, statusEl = null, } = config;
+        this.config = {
+            ...config,
+            autoSaveDelay,
+            enableKeyboardSave,
+            saveButton,
+            statusEl,
+        };
+        this.init();
+    }
+    init() {
+        void this.load();
+        this.config.textarea.addEventListener("input", () => {
+            this.markDirty();
+            this.scheduleSave();
+        });
+        this.config.textarea.addEventListener("blur", () => {
+            void this.save();
+        });
+        if (this.config.saveButton) {
+            this.config.saveButton.addEventListener("click", () => void this.save(true));
+        }
+        if (this.config.enableKeyboardSave) {
+            document.addEventListener("keydown", this.handleKeydown);
+            window.addEventListener("beforeunload", this.handleBeforeUnload);
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        document.removeEventListener("keydown", this.handleKeydown);
+        window.removeEventListener("beforeunload", this.handleBeforeUnload);
+    }
+    async load() {
+        const content = await this.config.onLoad();
+        this.lastSavedContent = content ?? "";
+        this.config.textarea.value = this.lastSavedContent;
+        this.setStatus("saved");
+    }
+    scheduleSave() {
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = setTimeout(() => void this.save(), this.config.autoSaveDelay);
+    }
+    markDirty() {
+        if (this.status !== "dirty") {
+            this.setStatus("dirty");
+        }
+    }
+    setStatus(status) {
+        this.status = status;
+        const { statusEl, saveButton } = this.config;
+        if (statusEl) {
+            statusEl.textContent = this.statusLabel(status);
+            statusEl.classList.toggle("muted", status === "saved" || status === "idle");
+            statusEl.classList.toggle("error", status === "error");
+            statusEl.classList.toggle("dirty", status === "dirty");
+        }
+        if (saveButton) {
+            if (status === "saving")
+                saveButton.setAttribute("disabled", "true");
+            else
+                saveButton.removeAttribute("disabled");
+        }
+    }
+    statusLabel(status) {
+        switch (status) {
+            case "saving":
+                return "Saving…";
+            case "saved":
+                return "Saved";
+            case "error":
+                return "Save failed";
+            case "dirty":
+                return "Unsaved changes";
+            default:
+                return "";
+        }
+    }
+    async save(force = false) {
+        if (this.destroyed)
+            return;
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        const value = this.config.textarea.value;
+        if (!force && value === this.lastSavedContent)
+            return;
+        this.setStatus("saving");
+        try {
+            const maybeHash = await this.config.onSave(value, this.baseHash);
+            if (typeof maybeHash === "string") {
+                this.baseHash = maybeHash;
+            }
+            this.lastSavedContent = value;
+            this.setStatus("saved");
+            // Clear saved indicator after a short delay to keep UI calm
+            setTimeout(() => {
+                if (this.status === "saved")
+                    this.setStatus("idle");
+            }, 1200);
+        }
+        catch (err) {
+            console.error("DocEditor save failed", err);
+            this.setStatus("error");
+        }
+    }
+}

codex_autorunner/static/env.js

@@ -1,3 +1,4 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
 const hasWindow = typeof window !== "undefined" && typeof window.location !== "undefined";
 const pathname = hasWindow ? window.location.pathname || "/" : "/";
 function normalizeBase(base) {