@tea-agent/loop-agent 0.32.0 → 0.32.1

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -0,0 +1,218 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { buildTurnProcessGroups } from "../../chat/turn-process.js";
+import { createChatSseEventApplier } from "./chat-sse-events.js";
+import { taskContextUnchanged } from "./format.js";
+const EMPTY_USAGE = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+};
+/**
+ * Thread state + SSE block parsing. The event-application logic itself lives
+ * in chat-sse-events.ts (createChatSseEventApplier); this hook owns the state
+ * slices it patches and the derived timeline projections.
+ */
+export function useChatThread(params) {
+    const { origin, refs, sessionId, setError, setProcessOpen } = params;
+    const [messages, setMessages] = useState([]);
+    const [toolCalls, setToolCalls] = useState([]);
+    const [operationCards, setOperationCards] = useState([]);
+    const [artifactCards, setArtifactCards] = useState([]);
+    const [historyLimit, setHistoryLimit] = useState(50);
+    const [unread, setUnread] = useState(0);
+    const [humanGateCards, setHumanGateCards] = useState([]);
+    const [interview, setInterview] = useState(null);
+    const [taskContext, setTaskContext] = useState(null);
+    const [contextLoading, setContextLoading] = useState(false);
+    const [usage, setUsage] = useState(EMPTY_USAGE);
+    const [streaming, setStreaming] = useState(false);
+    /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
+    const [streamingAssistantId, setStreamingAssistantId] = useState(null);
+    const [showSystemInMessages] = useState(false);
+    // All inputs are stable (state setters + the memoized refs bag), so the
+    // applier identity is stable across renders.
+    const applyChatSseEvent = useMemo(() => createChatSseEventApplier({
+        refs,
+        setError,
+        setProcessOpen,
+        setInterview,
+        setHumanGateCards,
+        setArtifactCards,
+        setStreaming,
+        setStreamingAssistantId,
+        setUnread,
+        setOperationCards,
+        setUsage,
+        setMessages,
+        setToolCalls,
+    }), [refs, setError, setProcessOpen]);
+    /** Parse + apply one raw SSE block (frames separated by \n\n). Returns the
+     *  eventId if the block carried an `id:` line (for Last-Event-ID tracking). */
+    const applySseBlock = useCallback((block, assistantId, options) => {
+        if (options?.targetSessionId &&
+            refs.sessionRef.current?.sessionId !== options.targetSessionId)
+            return null;
+        const lines = block.split("\n");
+        let eventName = "message";
+        let dataStr = "";
+        let eventId = null;
+        for (const line of lines) {
+            if (line.startsWith("event: "))
+                eventName = line.slice(7).trim();
+            else if (line.startsWith("data: "))
+                dataStr += line.slice(6);
+            else if (line.startsWith("id: "))
+                eventId = line.slice(4).trim();
+        }
+        if (!dataStr)
+            return eventId;
+        let data;
+        try {
+            data = JSON.parse(dataStr);
+        }
+        catch {
+            return eventId;
+        }
+        const dedupeId = eventId ?? (typeof data.eventId === "string" ? data.eventId : null);
+        if (dedupeId) {
+            if (refs.seenEventIdsRef.current.has(dedupeId))
+                return dedupeId;
+            refs.seenEventIdsRef.current.add(dedupeId);
+        }
+        applyChatSseEvent(eventName, data, assistantId, options);
+        return eventId ?? dedupeId;
+    }, [applyChatSseEvent, refs]);
+    const loadTaskContext = useCallback(async (targetSessionId, options) => {
+        const background = options?.background === true;
+        if (!background)
+            setContextLoading(true);
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/context`, { credentials: "include" });
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            if (body.context &&
+                refs.sessionRef.current?.sessionId === targetSessionId) {
+                setTaskContext((prev) => taskContextUnchanged(prev, body.context) ? prev : body.context);
+            }
+        }
+        finally {
+            if (!background)
+                setContextLoading(false);
+        }
+    }, [origin, refs]);
+    useEffect(() => {
+        if (sessionId)
+            void loadTaskContext(sessionId);
+    }, [sessionId, loadTaskContext]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const timer = window.setTimeout(() => {
+            void loadTaskContext(sessionId, { background: true });
+        }, 350);
+        return () => window.clearTimeout(timer);
+    }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
+    const visibleMessages = useMemo(() => messages
+        .filter((m) => m.role !== "system" || showSystemInMessages)
+        .slice(-historyLimit), [messages, showSystemInMessages, historyLimit]);
+    useEffect(() => {
+        const onVisibility = () => {
+            if (!document.hidden)
+                setUnread(0);
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+    }, []);
+    const processSummary = useMemo(() => {
+        if (toolCalls.length === 0)
+            return null;
+        const running = toolCalls.filter((t) => t.status === "running");
+        const errored = toolCalls.filter((t) => t.status === "error");
+        const current = running[running.length - 1];
+        let statusLabel = "完成";
+        let statusKind = "ok";
+        if (errored.length > 0) {
+            statusLabel = `${errored.length} 出错`;
+            statusKind = "error";
+        }
+        else if (running.length > 0) {
+            statusLabel = current ? `正在调用 ${current.toolName}` : "运行中";
+            statusKind = "running";
+        }
+        return {
+            count: toolCalls.length,
+            statusLabel,
+            statusKind,
+        };
+    }, [toolCalls]);
+    const turnGroups = useMemo(() => buildTurnProcessGroups({
+        messages: visibleMessages,
+        toolCalls,
+        streaming,
+        activeAssistantId: streamingAssistantId,
+    }), [visibleMessages, toolCalls, streaming, streamingAssistantId]);
+    /** Reset all session-scoped projections before adopting a fresh session. */
+    const resetForNewSession = useCallback(() => {
+        setMessages([]);
+        setToolCalls([]);
+        setOperationCards([]);
+        setHumanGateCards([]);
+        setArtifactCards([]);
+        setInterview(null);
+        setTaskContext(null);
+        setUsage(EMPTY_USAGE);
+        setStreaming(false);
+        setStreamingAssistantId(null);
+        setUnread(0);
+        setHistoryLimit(50);
+        refs.usageResponseKeysRef.current = new Set();
+    }, [refs]);
+    /** Adopt a freshly activated session's hydrated thread + streaming flags. */
+    const applyActivatedSession = useCallback((next) => {
+        setMessages(next.messages);
+        setToolCalls(next.toolCalls);
+        setOperationCards([]);
+        setHumanGateCards([]);
+        setArtifactCards([]);
+        setTaskContext(null);
+        setInterview(null);
+        setUsage(EMPTY_USAGE);
+        refs.usageResponseKeysRef.current = new Set();
+        setStreaming(next.streaming);
+        setStreamingAssistantId(null);
+        setUnread(0);
+        setHistoryLimit(50);
+    }, [refs]);
+    return {
+        messages,
+        setMessages,
+        toolCalls,
+        setToolCalls,
+        operationCards,
+        artifactCards,
+        historyLimit,
+        setHistoryLimit,
+        unread,
+        humanGateCards,
+        interview,
+        setInterview,
+        taskContext,
+        contextLoading,
+        usage,
+        streaming,
+        setStreaming,
+        streamingAssistantId,
+        setStreamingAssistantId,
+        visibleMessages,
+        turnGroups,
+        processSummary,
+        applyChatSseEvent,
+        applySseBlock,
+        loadTaskContext,
+        resetForNewSession,
+        applyActivatedSession,
+    };
+}

package/dist/worker/console/static-src/operator-chat/useComposer.js

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { SHORTCUTS } from "../../chat/shortcuts.js";
+import { confirmationToken } from "./format.js";
+/** Composer state: input text, @file palette, image attachments, /shortcuts,
+ *  IME composition guards, auto-grow and server-side draft sync. */
+export function useComposer(params) {
+    const { origin, sessionId, refs, setError } = params;
+    const [input, setInput] = useState("");
+    const [fileOptions, setFileOptions] = useState([]);
+    const [pendingImages, setPendingImages] = useState([]);
+    const [shortcutOpen, setShortcutOpen] = useState(false);
+    const [shortcutIndex, setShortcutIndex] = useState(0);
+    const textareaRef = useRef(null);
+    const handleInputChange = useCallback((value) => {
+        setInput(value);
+        setShortcutOpen(value.startsWith("/"));
+        setShortcutIndex(0);
+    }, []);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const match = input
+            .slice(0, textareaRef.current?.selectionStart ?? input.length)
+            .match(/(?:^|\s)@([^\s@]*)$/);
+        if (!match) {
+            setFileOptions([]);
+            return;
+        }
+        const timer = window.setTimeout(() => {
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`)
+                .then((r) => (r.ok ? r.json() : null))
+                .then((body) => setFileOptions((body?.files ?? []).map((item) => item.path)));
+        }, 150);
+        return () => window.clearTimeout(timer);
+    }, [origin, sessionId, input]);
+    const insertFileReference = useCallback((file) => {
+        const caret = textareaRef.current?.selectionStart ?? input.length;
+        const before = input.slice(0, caret);
+        const start = before.search(/@[^\s@]*$/);
+        if (start < 0)
+            return;
+        setInput(`${input.slice(0, start)}@${file} ${input.slice(caret)}`);
+        setFileOptions([]);
+    }, [input]);
+    const addImagesFromFiles = useCallback((files) => {
+        for (const file of Array.from(files).slice(0, 4)) {
+            if (!file.type.startsWith("image/") || file.size > 5 * 1024 * 1024) {
+                setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
+                continue;
+            }
+            const reader = new FileReader();
+            reader.onload = () => {
+                const value = String(reader.result ?? "");
+                const data = value.slice(value.indexOf(",") + 1);
+                setPendingImages((items) => [
+                    ...items,
+                    {
+                        name: file.name,
+                        type: "image",
+                        mimeType: file.type,
+                        data,
+                    },
+                ].slice(0, 4));
+            };
+            reader.readAsDataURL(file);
+        }
+    }, [setError]);
+    const removeImage = useCallback((image) => {
+        setPendingImages((items) => items.filter((item) => item !== image));
+    }, []);
+    // Auto-grow textarea height.
+    useLayoutEffect(() => {
+        const ta = textareaRef.current;
+        if (!ta)
+            return;
+        ta.style.height = "auto";
+        ta.style.height = `${Math.min(ta.scrollHeight, 280)}px`;
+    }, [input]);
+    // Debounced server-side composer draft sync.
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const timer = window.setTimeout(() => {
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/draft`, {
+                method: "PUT",
+                credentials: "include",
+                headers: {
+                    "content-type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                body: JSON.stringify({ text: input }),
+            });
+        }, 400);
+        return () => window.clearTimeout(timer);
+    }, [origin, sessionId, input]);
+    const filteredShortcuts = useMemo(() => input.startsWith("/")
+        ? SHORTCUTS.filter((item) => item.command.startsWith(input.trim().split(/\s+/, 1)[0].toLowerCase()))
+        : [], [input]);
+    const onCompositionStart = useCallback(() => {
+        refs.isComposingRef.current = true;
+    }, [refs]);
+    const onCompositionEnd = useCallback(() => {
+        refs.isComposingRef.current = false;
+        refs.compositionEndedAtRef.current = Date.now();
+    }, [refs]);
+    return {
+        input,
+        setInput,
+        handleInputChange,
+        fileOptions,
+        pendingImages,
+        setPendingImages,
+        addImagesFromFiles,
+        removeImage,
+        shortcutOpen,
+        setShortcutOpen,
+        shortcutIndex,
+        setShortcutIndex,
+        filteredShortcuts,
+        insertFileReference,
+        textareaRef,
+        onCompositionStart,
+        onCompositionEnd,
+    };
+}

package/dist/worker/console/static-src/operator-chat/useInterview.js

@@ -0,0 +1,108 @@
+import { useCallback, useState } from "react";
+import { confirmationToken } from "./format.js";
+/** Requirement Interview actions (grill-me flow) driven from the chat surface. */
+export function useInterview(params) {
+    const { origin, refs, thread, setError } = params;
+    const { interview, setInterview } = thread;
+    const [interviewAnswer, setInterviewAnswer] = useState("");
+    const startInterview = useCallback(async () => {
+        const active = refs.sessionRef.current;
+        if (!active)
+            return;
+        const taskId = window.prompt("Task ID（例如 2026-07-26-my-task）")?.trim();
+        if (!taskId)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({ taskId }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview({
+            interviewSessionId: body.interview?.sessionId,
+            taskId,
+            state: body.interview?.state,
+            question: body.question,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+        });
+    }, [origin, refs, setInterview, setError]);
+    const answerInterview = useCallback(async (response) => {
+        const active = refs.sessionRef.current;
+        if (!active || !interview?.interviewSessionId || !interview.question)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews/${interview.interviewSessionId}/answers`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({
+                questionId: interview.question.id,
+                response,
+                ...(response === "override" ? { text: interviewAnswer } : {}),
+            }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview((current) => ({
+            ...(current ?? {}),
+            state: body.interview?.state,
+            question: body.question,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+            taskKindRecommendation: body.taskKindRecommendation ?? current?.taskKindRecommendation,
+        }));
+        setInterviewAnswer("");
+    }, [origin, refs, interview, interviewAnswer, setInterview, setError]);
+    const confirmTaskKind = useCallback(async () => {
+        const active = refs.sessionRef.current;
+        if (!active ||
+            !interview?.interviewSessionId ||
+            !interview.taskKindRecommendation)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews/${interview.interviewSessionId}/task-kind/confirm`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({ taskKind: interview.taskKindRecommendation }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview((current) => ({
+            ...(current ?? {}),
+            confirmedTaskKind: current?.taskKindRecommendation,
+            taskKindRecommendation: undefined,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+        }));
+    }, [origin, refs, interview, setInterview, setError]);
+    return {
+        interviewAnswer,
+        setInterviewAnswer,
+        startInterview,
+        answerInterview,
+        confirmTaskKind,
+    };
+}

package/dist/worker/console/static-src/operator-chat/useRepoBrowser.js

@@ -0,0 +1,123 @@
+import { useCallback, useEffect, useState } from "react";
+import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
+/** Left-rail repo tree + file preview tabs state. */
+export function useRepoBrowser(params) {
+    const { origin, refs, sessionId, setError } = params;
+    const [tree, setTree] = useState({});
+    const [expandedDirs, setExpandedDirs] = useState(new Set());
+    const [treeError, setTreeError] = useState(null);
+    const [previews, setPreviews] = useState([]);
+    const [activePreviewPath, setActivePreviewPath] = useState(null);
+    const [previewLoading, setPreviewLoading] = useState(false);
+    const loadTree = useCallback(async (directory = "") => {
+        try {
+            setTreeError(null);
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/tree?path=${encodeURIComponent(directory)}`, { credentials: "include" });
+            const body = (await res.json());
+            if (!res.ok)
+                throw new Error(body.error?.message ?? "无法读取仓库目录");
+            setTree((current) => ({
+                ...current,
+                [directory]: body.data?.entries ?? [],
+            }));
+        }
+        catch (error) {
+            setTreeError(error instanceof Error ? error.message : String(error));
+        }
+    }, [origin]);
+    useEffect(() => {
+        void loadTree();
+    }, [loadTree]);
+    const openPreview = useCallback(async (file) => {
+        setPreviewLoading(true);
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}`, { credentials: "include" });
+            const body = (await res.json());
+            if (!res.ok || !body.data)
+                throw new Error(body.error?.message ?? "无法预览文件");
+            setPreviews((current) => {
+                const next = [
+                    ...current.filter((item) => item.path !== body.data.path),
+                    body.data,
+                ];
+                const activeSessionId = refs.sessionRef.current?.sessionId;
+                if (activeSessionId)
+                    window.localStorage.setItem(`${ACTIVE_CHAT_SESSION_STORAGE_KEY}.previews.${activeSessionId}`, JSON.stringify(next.map((item) => item.path)));
+                return next;
+            });
+            setActivePreviewPath(body.data.path);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setPreviewLoading(false);
+        }
+    }, [origin, refs, setError]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        let paths = [];
+        try {
+            const stored = JSON.parse(window.localStorage.getItem(`${ACTIVE_CHAT_SESSION_STORAGE_KEY}.previews.${sessionId}`) ?? "[]");
+            if (Array.isArray(stored))
+                paths = stored
+                    .filter((item) => typeof item === "string")
+                    .slice(0, 10);
+        }
+        catch {
+            // Invalid local preference is ignored; file content is always re-fetched.
+        }
+        if (!paths.length)
+            return;
+        void Promise.all(paths.map(async (file) => {
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}`, { credentials: "include" });
+            if (!res.ok)
+                return undefined;
+            return (await res.json()).data;
+        })).then((restored) => {
+            if (refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            const available = restored.filter((item) => Boolean(item));
+            setPreviews(available);
+            setActivePreviewPath(available.at(-1)?.path ?? null);
+        });
+    }, [origin, sessionId, refs]);
+    const toggleDir = useCallback((dir) => {
+        setExpandedDirs((current) => {
+            const next = new Set(current);
+            if (next.has(dir))
+                next.delete(dir);
+            else
+                next.add(dir);
+            return next;
+        });
+        if (!tree[dir])
+            void loadTree(dir);
+    }, [tree, loadTree]);
+    const closePreview = useCallback((file) => {
+        setPreviews((current) => {
+            const next = current.filter((item) => item.path !== file);
+            if (sessionId)
+                window.localStorage.setItem(`${ACTIVE_CHAT_SESSION_STORAGE_KEY}.previews.${sessionId}`, JSON.stringify(next.map((item) => item.path)));
+            return next;
+        });
+        setActivePreviewPath((current) => current === file
+            ? (previews.find((item) => item.path !== file)?.path ?? null)
+            : current);
+    }, [previews, sessionId]);
+    return {
+        tree,
+        expandedDirs,
+        treeError,
+        previews,
+        activePreviewPath,
+        setActivePreviewPath,
+        previewLoading,
+        setPreviews,
+        loadTree,
+        openPreview,
+        closePreview,
+        toggleDir,
+    };
+}