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

codex_autorunner/static/ticketChatActions.js

@@ -0,0 +1,333 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+/**
+ * Ticket Chat Actions - handles sending messages, applying/discarding patches
+ */
+import { api, flash, splitMarkdownFrontmatter } from "./utils.js";
+import { performTicketChatRequest } from "./ticketChatStream.js";
+import { renderTicketMessages } from "./ticketChatEvents.js";
+import { publish } from "./bus.js";
+import { createDocChat } from "./docChatCore.js";
+import { saveTicketChatHistory } from "./ticketChatStorage.js";
+import { renderDiff } from "./diffRenderer.js";
+// Limits for events display
+export const TICKET_CHAT_EVENT_LIMIT = 8;
+export const TICKET_CHAT_EVENT_MAX = 50;
+export const ticketChat = createDocChat({
+    idPrefix: "ticket-chat",
+    storage: { keyPrefix: "car-ticket-chat-", maxMessages: 50, version: 1 },
+    limits: { eventVisible: TICKET_CHAT_EVENT_LIMIT, eventMax: TICKET_CHAT_EVENT_MAX },
+    styling: {
+        eventClass: "ticket-chat-event",
+        eventTitleClass: "ticket-chat-event-title",
+        eventSummaryClass: "ticket-chat-event-summary",
+        eventDetailClass: "ticket-chat-event-detail",
+        eventMetaClass: "ticket-chat-event-meta",
+        eventsEmptyClass: "ticket-chat-events-empty",
+        eventsWaitingClass: "ticket-chat-events-waiting",
+        eventsHiddenClass: "hidden",
+        messagesClass: "ticket-chat-message",
+        messageRoleClass: "ticket-chat-message-role",
+        messageContentClass: "ticket-chat-message-content",
+        messageMetaClass: "ticket-chat-message-meta",
+        messageUserClass: "user",
+        messageAssistantClass: "assistant",
+        messageAssistantThinkingClass: "thinking",
+        messageAssistantFinalClass: "final",
+    },
+});
+// Extend state with ticket-specific fields
+export const ticketChatState = Object.assign(ticketChat.state, {
+    ticketIndex: null,
+    draft: null,
+});
+export function getTicketChatElements() {
+    const base = ticketChat.elements;
+    return {
+        input: base.input,
+        sendBtn: base.sendBtn,
+        voiceBtn: base.voiceBtn,
+        cancelBtn: base.cancelBtn,
+        newThreadBtn: base.newThreadBtn,
+        statusEl: base.statusEl,
+        streamEl: base.streamEl,
+        eventsMain: base.eventsMain,
+        eventsList: base.eventsList,
+        eventsCount: base.eventsCount,
+        eventsToggle: base.eventsToggle,
+        messagesEl: base.messagesEl,
+        // Content area elements - mutually exclusive with patch preview
+        contentTextarea: document.getElementById("ticket-editor-content"),
+        contentToolbar: document.getElementById("ticket-editor-toolbar"),
+        // Patch preview elements - mutually exclusive with content area
+        patchMain: document.getElementById("ticket-patch-main"),
+        patchBody: document.getElementById("ticket-patch-body"),
+        patchStatus: document.getElementById("ticket-patch-status"),
+        applyBtn: document.getElementById("ticket-patch-apply"),
+        discardBtn: document.getElementById("ticket-patch-discard"),
+        agentSelect: document.getElementById("ticket-chat-agent-select"),
+        modelSelect: document.getElementById("ticket-chat-model-select"),
+        reasoningSelect: document.getElementById("ticket-chat-reasoning-select"),
+    };
+}
+export function resetTicketChatState() {
+    ticketChatState.status = "idle";
+    ticketChatState.error = "";
+    ticketChatState.streamText = "";
+    ticketChatState.statusText = "";
+    ticketChatState.controller = null;
+    // Note: events are cleared at the start of each new request, not here
+    // Messages persist across requests within the same ticket
+}
+export async function startNewTicketChatThread() {
+    if (ticketChatState.ticketIndex == null)
+        return;
+    const confirmed = window.confirm("Start a new conversation thread for this ticket?");
+    if (!confirmed)
+        return;
+    try {
+        const key = `ticket_chat.${ticketChatState.ticketIndex}`;
+        await api(`/api/app-server/threads/reset`, {
+            method: "POST",
+            body: { key },
+        });
+        // Clear local message history
+        ticketChatState.messages = [];
+        saveTicketChatHistory(ticketChatState.ticketIndex, []);
+        clearTicketEvents();
+        flash("New thread started");
+    }
+    catch (err) {
+        flash(`Failed to reset thread: ${err.message}`, "error");
+    }
+    finally {
+        renderTicketChat();
+        renderTicketMessages();
+    }
+}
+/**
+ * Clear events at the start of a new request.
+ * Events are transient (thinking/tool calls) and reset each turn.
+ */
+export function clearTicketEvents() {
+    ticketChat.clearEvents();
+}
+/**
+ * Add a user message to the chat history.
+ */
+export function addUserMessage(content) {
+    ticketChat.addUserMessage(content);
+}
+/**
+ * Add an assistant message to the chat history.
+ * Prevents duplicates by checking if the same content was just added.
+ */
+export function addAssistantMessage(content, isFinal = true) {
+    ticketChat.addAssistantMessage(content, isFinal);
+}
+export function setTicketIndex(index) {
+    const changed = ticketChatState.ticketIndex !== index;
+    ticketChatState.ticketIndex = index;
+    ticketChatState.draft = null;
+    resetTicketChatState();
+    // Clear chat history when switching tickets
+    if (changed) {
+        ticketChat.setTarget(index != null ? String(index) : null);
+    }
+}
+export function renderTicketChat() {
+    const els = getTicketChatElements();
+    // Shared chat render (status, events, messages)
+    ticketChat.render();
+    // MUTUALLY EXCLUSIVE: Show either the content editor OR the patch preview, never both.
+    // This prevents confusion about which view is the "current" state.
+    const hasDraft = !!ticketChatState.draft;
+    // Hide content area when showing patch preview
+    if (els.contentTextarea) {
+        els.contentTextarea.classList.toggle("hidden", hasDraft);
+    }
+    if (els.contentToolbar) {
+        els.contentToolbar.classList.toggle("hidden", hasDraft);
+    }
+    // Show patch preview only when there's a draft
+    if (els.patchMain) {
+        els.patchMain.classList.toggle("hidden", !hasDraft);
+        if (hasDraft) {
+            if (els.patchBody) {
+                renderDiff(ticketChatState.draft.patch || "(no changes)", els.patchBody);
+            }
+            if (els.patchStatus) {
+                els.patchStatus.textContent = ticketChatState.draft.agentMessage || "";
+            }
+        }
+    }
+}
+export async function sendTicketChat() {
+    const els = getTicketChatElements();
+    const message = (els.input?.value || "").trim();
+    if (!message) {
+        ticketChatState.error = "Enter a message to send.";
+        renderTicketChat();
+        return;
+    }
+    if (ticketChatState.status === "running") {
+        ticketChatState.error = "Ticket chat already running.";
+        renderTicketChat();
+        flash("Ticket chat already running", "error");
+        return;
+    }
+    if (ticketChatState.ticketIndex == null) {
+        ticketChatState.error = "No ticket selected.";
+        renderTicketChat();
+        return;
+    }
+    resetTicketChatState();
+    ticketChatState.status = "running";
+    ticketChatState.statusText = "queued";
+    ticketChatState.controller = new AbortController();
+    renderTicketChat();
+    if (els.input) {
+        els.input.value = "";
+    }
+    const agent = els.agentSelect?.value || "codex";
+    const model = els.modelSelect?.value || undefined;
+    const reasoning = els.reasoningSelect?.value || undefined;
+    try {
+        await performTicketChatRequest(ticketChatState.ticketIndex, message, ticketChatState.controller.signal, {
+            agent,
+            model,
+            reasoning,
+        });
+        // Try to load any pending draft
+        await loadTicketPending(ticketChatState.ticketIndex, true);
+        if (ticketChatState.status === "running") {
+            ticketChatState.status = "done";
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.name === "AbortError") {
+            ticketChatState.status = "interrupted";
+            ticketChatState.error = "";
+        }
+        else {
+            ticketChatState.status = "error";
+            ticketChatState.error = error.message || "Ticket chat failed";
+        }
+    }
+    finally {
+        ticketChatState.controller = null;
+        renderTicketChat();
+    }
+}
+export async function cancelTicketChat() {
+    if (ticketChatState.status !== "running")
+        return;
+    // Abort the request
+    if (ticketChatState.controller) {
+        ticketChatState.controller.abort();
+    }
+    // Send interrupt to server
+    if (ticketChatState.ticketIndex != null) {
+        try {
+            await api(`/api/tickets/${ticketChatState.ticketIndex}/chat/interrupt`, {
+                method: "POST",
+            });
+        }
+        catch (err) {
+            // Ignore interrupt errors
+        }
+    }
+    ticketChatState.status = "interrupted";
+    ticketChatState.error = "";
+    ticketChatState.statusText = "";
+    ticketChatState.controller = null;
+    renderTicketChat();
+}
+export async function applyTicketPatch() {
+    if (ticketChatState.ticketIndex == null) {
+        flash("No ticket selected", "error");
+        return;
+    }
+    if (!ticketChatState.draft) {
+        flash("No draft to apply", "error");
+        return;
+    }
+    try {
+        const res = await api(`/api/tickets/${ticketChatState.ticketIndex}/chat/apply`, { method: "POST" });
+        ticketChatState.draft = null;
+        flash("Draft applied");
+        // Notify that tickets changed
+        publish("tickets:updated", {});
+        // Update the editor textarea if content is returned
+        if (res.content) {
+            const textarea = document.getElementById("ticket-editor-content");
+            if (textarea) {
+                const [fmYaml, body] = splitMarkdownFrontmatter(res.content);
+                if (fmYaml !== null) {
+                    textarea.value = body.trimStart();
+                }
+                else {
+                    textarea.value = res.content.trimStart();
+                }
+                // Trigger input event to update undo stack and autosave
+                textarea.dispatchEvent(new Event("input", { bubbles: true }));
+            }
+        }
+    }
+    catch (err) {
+        const error = err;
+        flash(error.message || "Failed to apply draft", "error");
+    }
+    finally {
+        renderTicketChat();
+    }
+}
+export async function discardTicketPatch() {
+    if (ticketChatState.ticketIndex == null) {
+        flash("No ticket selected", "error");
+        return;
+    }
+    try {
+        await api(`/api/tickets/${ticketChatState.ticketIndex}/chat/discard`, { method: "POST" });
+        ticketChatState.draft = null;
+        flash("Draft discarded");
+    }
+    catch (err) {
+        const error = err;
+        flash(error.message || "Failed to discard draft", "error");
+    }
+    finally {
+        renderTicketChat();
+    }
+}
+export async function loadTicketPending(index, silent = false) {
+    try {
+        const res = await api(`/api/tickets/${index}/chat/pending`, { method: "GET" });
+        ticketChatState.draft = {
+            patch: res.patch || "",
+            content: res.content || "",
+            agentMessage: res.agent_message || "",
+            createdAt: res.created_at || "",
+            baseHash: res.base_hash || "",
+        };
+        if (!silent) {
+            flash("Loaded pending draft");
+        }
+    }
+    catch (err) {
+        const error = err;
+        const message = error?.message || "";
+        if (message.includes("No pending")) {
+            ticketChatState.draft = null;
+            if (!silent) {
+                flash("No pending draft");
+            }
+        }
+        else if (!silent) {
+            flash(message || "Failed to load pending draft", "error");
+        }
+    }
+    finally {
+        renderTicketChat();
+    }
+}

codex_autorunner/static/ticketChatEvents.js

@@ -0,0 +1,16 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { ticketChat } from "./ticketChatActions.js";
+// This module now delegates to docChatCore for rendering and event parsing.
+export function applyTicketEvent(payload) {
+    ticketChat.applyAppEvent(payload);
+}
+export function renderTicketEvents() {
+    ticketChat.renderEvents();
+}
+export function renderTicketMessages() {
+    ticketChat.renderMessages();
+}
+export function initTicketChatEvents() {
+    // Toggle already wired in docChatCore constructor.
+    return;
+}

codex_autorunner/static/ticketChatStorage.js

@@ -0,0 +1,16 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { clearChatHistory, loadChatHistory, saveChatHistory, } from "./docChatStorage.js";
+const STORAGE_CONFIG = {
+    keyPrefix: "car-ticket-chat-",
+    maxMessages: 50,
+    version: 1,
+};
+export function saveTicketChatHistory(ticketIndex, messages) {
+    saveChatHistory(STORAGE_CONFIG, String(ticketIndex), messages);
+}
+export function loadTicketChatHistory(ticketIndex) {
+    return loadChatHistory(STORAGE_CONFIG, String(ticketIndex));
+}
+export function clearTicketChatHistory(ticketIndex) {
+    clearChatHistory(STORAGE_CONFIG, String(ticketIndex));
+}

codex_autorunner/static/ticketChatStream.js

@@ -0,0 +1,264 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+/**
+ * Ticket Chat Stream - handles SSE streaming for ticket chat
+ */
+import { resolvePath, getAuthToken } from "./utils.js";
+import { ticketChatState, renderTicketChat, clearTicketEvents, addUserMessage, addAssistantMessage, } from "./ticketChatActions.js";
+import { applyTicketEvent, renderTicketEvents, renderTicketMessages } from "./ticketChatEvents.js";
+const decoder = new TextDecoder();
+function parseMaybeJson(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+export async function performTicketChatRequest(ticketIndex, message, signal, options = {}) {
+    // Clear events from previous request and add user message to history
+    clearTicketEvents();
+    addUserMessage(message);
+    // Render both chat (for container visibility) and messages
+    renderTicketChat();
+    renderTicketMessages();
+    const endpoint = resolvePath(`/api/tickets/${ticketIndex}/chat`);
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    const token = getAuthToken();
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const payload = {
+        message,
+        stream: true,
+    };
+    if (options.agent)
+        payload.agent = options.agent;
+    if (options.model)
+        payload.model = options.model;
+    if (options.reasoning)
+        payload.reasoning = options.reasoning;
+    const res = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        let detail = text;
+        try {
+            const parsed = JSON.parse(text);
+            detail = parsed.detail || parsed.error || text;
+        }
+        catch {
+            // 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 readTicketChatStream(res);
+    }
+    else {
+        // Non-streaming response
+        const responsePayload = contentType.includes("application/json")
+            ? await res.json()
+            : await res.text();
+        applyTicketChatResult(responsePayload);
+    }
+}
+async function readTicketChatStream(res) {
+    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 = decoder.decode(value, { stream: true });
+        // Handle escaped newlines
+        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;
+        // Split on double newlines (SSE message delimiter)
+        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");
+            handleTicketStreamEvent(event, data);
+        }
+    }
+}
+function handleTicketStreamEvent(event, rawData) {
+    const parsed = parseMaybeJson(rawData);
+    switch (event) {
+        case "status": {
+            const status = typeof parsed === "string"
+                ? parsed
+                : parsed.status || "";
+            ticketChatState.statusText = status;
+            renderTicketChat();
+            renderTicketEvents();
+            break;
+        }
+        case "token": {
+            const token = typeof parsed === "string"
+                ? parsed
+                : parsed.token ||
+                    parsed.text ||
+                    rawData ||
+                    "";
+            ticketChatState.streamText = (ticketChatState.streamText || "") + token;
+            if (!ticketChatState.statusText || ticketChatState.statusText === "queued") {
+                ticketChatState.statusText = "responding";
+            }
+            renderTicketChat();
+            break;
+        }
+        case "update": {
+            applyTicketChatResult(parsed);
+            break;
+        }
+        case "event":
+        case "app-server": {
+            // App-server events (thinking, tool calls, etc.)
+            applyTicketEvent(parsed);
+            renderTicketEvents();
+            break;
+        }
+        case "error": {
+            const message = typeof parsed === "object" && parsed !== null
+                ? parsed.detail ||
+                    parsed.error ||
+                    rawData
+                : rawData || "Ticket chat failed";
+            ticketChatState.status = "error";
+            ticketChatState.error = String(message);
+            // Add error as assistant message
+            addAssistantMessage(`Error: ${message}`, true);
+            renderTicketChat();
+            renderTicketMessages();
+            throw new Error(String(message));
+        }
+        case "interrupted": {
+            const message = typeof parsed === "object" && parsed !== null
+                ? parsed.detail || rawData
+                : rawData || "Ticket chat interrupted";
+            ticketChatState.status = "interrupted";
+            ticketChatState.error = "";
+            ticketChatState.statusText = String(message);
+            // Add interrupted message
+            addAssistantMessage("Request interrupted", true);
+            renderTicketChat();
+            renderTicketMessages();
+            break;
+        }
+        case "done":
+        case "finish": {
+            ticketChatState.status = "done";
+            // Final render to ensure UI is up to date
+            renderTicketChat();
+            renderTicketMessages();
+            renderTicketEvents();
+            break;
+        }
+        default:
+            // Unknown event - try to parse as app-server event
+            if (typeof parsed === "object" && parsed !== null) {
+                const messageObj = parsed;
+                if (messageObj.method || messageObj.message) {
+                    applyTicketEvent(parsed);
+                    renderTicketEvents();
+                }
+            }
+            break;
+    }
+}
+function applyTicketChatResult(payload) {
+    if (!payload || typeof payload !== "object")
+        return;
+    const result = payload;
+    if (result.status === "interrupted") {
+        ticketChatState.status = "interrupted";
+        ticketChatState.error = "";
+        addAssistantMessage("Request interrupted", true);
+        renderTicketChat();
+        renderTicketMessages();
+        return;
+    }
+    if (result.status === "error" || result.error) {
+        ticketChatState.status = "error";
+        ticketChatState.error =
+            result.detail || result.error || "Chat failed";
+        addAssistantMessage(`Error: ${ticketChatState.error}`, true);
+        renderTicketChat();
+        renderTicketMessages();
+        return;
+    }
+    // Success
+    ticketChatState.status = "done";
+    if (result.message) {
+        ticketChatState.streamText = result.message;
+    }
+    if (result.agent_message || result.agentMessage) {
+        ticketChatState.statusText =
+            result.agent_message || result.agentMessage || "";
+    }
+    // Check for draft/patch in response
+    const hasDraft = result.has_draft ?? result.hasDraft;
+    if (hasDraft === false) {
+        ticketChatState.draft = null;
+    }
+    else if (hasDraft === true || result.draft || result.patch || result.content) {
+        ticketChatState.draft = {
+            content: result.content || "",
+            patch: result.patch || "",
+            agentMessage: result.agent_message || result.agentMessage || "",
+            createdAt: result.created_at || result.createdAt || "",
+            baseHash: result.base_hash || result.baseHash || "",
+        };
+    }
+    // Add assistant message from response
+    const responseText = ticketChatState.streamText ||
+        ticketChatState.statusText ||
+        (ticketChatState.draft ? "Changes ready to apply" : "Done");
+    if (responseText && ticketChatState.messages.length > 0) {
+        // Only add if we have messages (i.e., a user message was sent)
+        const lastMessage = ticketChatState.messages[ticketChatState.messages.length - 1];
+        // Avoid duplicate assistant messages
+        if (lastMessage.role === "user") {
+            addAssistantMessage(responseText, true);
+        }
+    }
+    renderTicketChat();
+    renderTicketMessages();
+    renderTicketEvents();
+}