@fromsko/chat-ui 0.0.0-stage → 0.1.6

package/lib/domain/reducer.js

@@ -0,0 +1,442 @@
+const EMPTY = [];
+function cloneMessages(messages, id, patch) {
+    const list = messages[id] ?? EMPTY;
+    return { ...messages, [id]: patch(list) };
+}
+function patchMessageAt(state, id, index, patch) {
+    return {
+        ...state,
+        messages: cloneMessages(state.messages, id, (list) => list.map((m, i) => (i === index ? patch(m) : m))),
+    };
+}
+function settleParts(parts) {
+    if (!parts)
+        return parts;
+    return parts.map((p) => p.kind === "reasoning" && p.streaming ? { ...p, streaming: false } : p);
+}
+function patchStreaming(state, requestId, patch) {
+    for (const [cid, list] of Object.entries(state.messages)) {
+        const idx = list.findIndex((m) => m.state === "streaming" && m.requestId === requestId);
+        if (idx >= 0)
+            return patchMessageAt(state, cid, idx, patch);
+    }
+    const active = state.activeId ? state.messages[state.activeId] : undefined;
+    if (active) {
+        for (let i = active.length - 1; i >= 0; i--) {
+            const m = active[i];
+            if (m.state === "streaming" && m.requestId === undefined) {
+                return patchMessageAt(state, state.activeId, i, patch);
+            }
+        }
+    }
+    return state;
+}
+function patchByRequest(state, requestId, patch) {
+    for (const [cid, list] of Object.entries(state.messages)) {
+        const idx = list.findIndex((m) => m.requestId === requestId);
+        if (idx >= 0)
+            return patchMessageAt(state, cid, idx, patch);
+    }
+    return state;
+}
+function resolveTargetConversation(state, requestId) {
+    if (!requestId)
+        return state.activeId ?? undefined;
+    for (const [cid, list] of Object.entries(state.messages)) {
+        if (list.some((m) => m.requestId === requestId))
+            return cid;
+    }
+    return undefined;
+}
+export function conversationReducer(state, action) {
+    switch (action.type) {
+        case "select":
+            return {
+                ...state,
+                activeId: action.id,
+                conversations: state.conversations.map((c) => c.id === action.id ? { ...c, unread: 0 } : c),
+            };
+        case "query":
+            return { ...state, query: action.value };
+        case "draft":
+            return {
+                ...state,
+                drafts: { ...state.drafts, [action.id]: action.value },
+            };
+        case "append":
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, action.id, (list) => [
+                    ...list,
+                    action.message,
+                ]),
+            };
+        case "hydrateMessages": {
+            const existing = state.messages[action.id];
+            if (existing && existing.length > 0)
+                return state;
+            return {
+                ...state,
+                messages: { ...state.messages, [action.id]: action.messages },
+            };
+        }
+        case "deleteMessage":
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, action.id, (list) => list.filter((m) => m.id !== action.messageId)),
+            };
+        case "insertMessageAt":
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, action.id, (list) => {
+                    const at = Math.max(0, Math.min(action.index, list.length));
+                    const next = [...list];
+                    next.splice(at, 0, action.message);
+                    return next;
+                }),
+            };
+        case "bindRequest":
+            return patchStreaming(state, action.requestId, (m) => ({
+                ...m,
+                requestId: action.requestId,
+            }));
+        case "streamDelta":
+            return patchStreaming(state, action.requestId, (m) => ({
+                ...m,
+                text: m.text + action.text,
+                parts: settleParts(m.parts),
+            }));
+        case "streamEnd": {
+            const owner = resolveTargetConversation(state, action.requestId);
+            if (!owner)
+                return state;
+            let next = patchStreaming(state, action.requestId, (m) => ({
+                ...m,
+                state: action.outcome,
+                parts: settleParts(m.parts),
+                text: action.outcome === "error"
+                    ? `${m.text}\n【失败】${action.error ?? "未知错误"}`
+                    : m.text,
+            }));
+            if (owner !== next.activeId && action.outcome === "done") {
+                next = {
+                    ...next,
+                    conversations: next.conversations.map((c) => c.id === owner ? { ...c, unread: c.unread + 1 } : c),
+                };
+            }
+            return next;
+        }
+        case "streamToolCall":
+            return patchStreaming(state, action.requestId, (m) => ({
+                ...m,
+                parts: [
+                    ...(m.parts ?? []),
+                    {
+                        kind: "tool",
+                        toolCallId: action.toolCallId,
+                        tool: action.name,
+                        state: "running",
+                        args: action.args,
+                    },
+                ],
+            }));
+        case "streamToolResult":
+            return patchByRequest(state, action.requestId, (m) => ({
+                ...m,
+                parts: (m.parts ?? []).map((p) => p.kind === "tool" && p.toolCallId === action.toolCallId
+                    ? {
+                        ...p,
+                        state: action.isError ? "error" : "finished",
+                        result: action.result,
+                    }
+                    : p),
+            }));
+        case "streamReasoning":
+            return patchStreaming(state, action.requestId, (m) => {
+                const parts = m.parts ?? [];
+                const idx = parts.findIndex((p) => p.kind === "reasoning");
+                if (idx >= 0) {
+                    const next = [...parts];
+                    const r = next[idx];
+                    if (r.kind === "reasoning") {
+                        next[idx] = {
+                            ...r,
+                            text: r.text + action.text,
+                            streaming: true,
+                        };
+                    }
+                    return { ...m, parts: next };
+                }
+                return {
+                    ...m,
+                    parts: [
+                        { kind: "reasoning", text: action.text, streaming: true },
+                        ...parts,
+                    ],
+                };
+            });
+        case "streamContextUsage":
+            return patchStreaming(state, action.requestId, (m) => ({
+                ...m,
+                contextUsage: {
+                    input: action.inputTokens,
+                    output: action.outputTokens,
+                    window: action.window,
+                },
+            }));
+        case "streamMemory": {
+            const withPart = patchByRequest(state, action.requestId, (m) => ({
+                ...m,
+                parts: [
+                    ...(m.parts ?? []),
+                    {
+                        kind: "memory",
+                        count: action.count,
+                        excerpt: action.excerpt,
+                        requestId: action.requestId,
+                    },
+                ],
+            }));
+            if (withPart !== state)
+                return withPart;
+            const target = resolveTargetConversation(state, action.requestId) ??
+                state.activeId ??
+                undefined;
+            if (!target)
+                return state;
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, target, (list) => [
+                    ...list,
+                    {
+                        id: `${target}-m-${action.requestId}`,
+                        role: "system",
+                        text: "",
+                        timeLabel: "",
+                        parts: [
+                            {
+                                kind: "memory",
+                                count: action.count,
+                                excerpt: action.excerpt,
+                                requestId: action.requestId,
+                            },
+                        ],
+                    },
+                ]),
+            };
+        }
+        case "streamCompaction": {
+            const target = resolveTargetConversation(state, action.requestId) ??
+                state.activeId ??
+                undefined;
+            if (!target)
+                return state;
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, target, (list) => [
+                    ...list,
+                    {
+                        id: `${target}-c-${action.requestId ?? "legacy"}`,
+                        role: "system",
+                        text: "",
+                        timeLabel: "",
+                        parts: [
+                            {
+                                kind: "compact",
+                                beforeTokens: action.beforeTokens,
+                                afterTokens: action.afterTokens,
+                                reason: action.reason,
+                                requestId: action.requestId ?? undefined,
+                            },
+                        ],
+                    },
+                ]),
+            };
+        }
+        case "streamDisplay": {
+            const withPart = patchByRequest(state, action.requestId, (m) => ({
+                ...m,
+                parts: [
+                    ...(m.parts ?? []),
+                    {
+                        kind: "display",
+                        view: action.view,
+                        title: action.title,
+                        payload: action.payload,
+                        requestId: action.requestId,
+                    },
+                ],
+            }));
+            if (withPart !== state)
+                return withPart;
+            const target = resolveTargetConversation(state, action.requestId) ??
+                state.activeId ??
+                undefined;
+            if (!target)
+                return state;
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, target, (list) => [
+                    ...list,
+                    {
+                        id: `${target}-d-${action.requestId}`,
+                        role: "system",
+                        text: "",
+                        timeLabel: "",
+                        parts: [
+                            {
+                                kind: "display",
+                                view: action.view,
+                                title: action.title,
+                                payload: action.payload,
+                                requestId: action.requestId,
+                            },
+                        ],
+                    },
+                ]),
+            };
+        }
+        case "streamOutput": {
+            const withPart = patchByRequest(state, action.requestId, (m) => ({
+                ...m,
+                parts: [
+                    ...(m.parts ?? []),
+                    {
+                        kind: "output",
+                        outputKind: action.outputKind,
+                        label: action.label,
+                        value: action.value,
+                        requestId: action.requestId,
+                    },
+                ],
+            }));
+            if (withPart !== state)
+                return withPart;
+            const target = resolveTargetConversation(state, action.requestId) ??
+                state.activeId ??
+                undefined;
+            if (!target)
+                return state;
+            return {
+                ...state,
+                messages: cloneMessages(state.messages, target, (list) => [
+                    ...list,
+                    {
+                        id: `${target}-o-${action.requestId}`,
+                        role: "system",
+                        text: "",
+                        timeLabel: "",
+                        parts: [
+                            {
+                                kind: "output",
+                                outputKind: action.outputKind,
+                                label: action.label,
+                                value: action.value,
+                                requestId: action.requestId,
+                            },
+                        ],
+                    },
+                ]),
+            };
+        }
+        case "addConversation":
+            return {
+                ...state,
+                conversations: [action.conversation, ...state.conversations],
+                activeId: action.conversation.id,
+            };
+        case "dropConversation": {
+            const messages = { ...state.messages };
+            delete messages[action.id];
+            const drafts = { ...state.drafts };
+            delete drafts[action.id];
+            const conversations = state.conversations.filter((c) => c.id !== action.id);
+            return {
+                ...state,
+                messages,
+                drafts,
+                conversations,
+                activeId: state.activeId === action.id
+                    ? (conversations[0]?.id ?? null)
+                    : state.activeId,
+            };
+        }
+        case "persistError":
+            return { ...state, persistError: action.value };
+        case "togglePin":
+            return {
+                ...state,
+                conversations: state.conversations.map((c) => c.id === action.id ? { ...c, pinned: !c.pinned } : c),
+            };
+        case "toggleMute":
+            return {
+                ...state,
+                conversations: state.conversations.map((c) => c.id === action.id ? { ...c, muted: !c.muted } : c),
+            };
+        case "renameConversation":
+            return {
+                ...state,
+                conversations: state.conversations.map((c) => c.id === action.id ? { ...c, title: action.title } : c),
+            };
+        case "setMembers":
+            return {
+                ...state,
+                conversations: state.conversations.map((c) => c.id === action.id
+                    ? {
+                        ...c,
+                        memberIds: action.memberIds,
+                        kind: action.memberIds.length > 1 ? "group" : "direct",
+                    }
+                    : c),
+            };
+        case "setAutoRespond":
+            return {
+                ...state,
+                conversations: state.conversations.map((c) => c.id === action.id ? { ...c, autoRespond: action.value } : c),
+            };
+        case "createGroup":
+            return {
+                ...state,
+                conversations: [
+                    {
+                        id: action.id,
+                        kind: "group",
+                        title: action.title,
+                        memberIds: action.members,
+                        autoRespond: false,
+                        unread: 0,
+                        pinned: false,
+                        muted: false,
+                        lastPreview: "群聊已创建",
+                        timeLabel: "刚刚",
+                    },
+                    ...state.conversations,
+                ],
+                activeId: action.id,
+            };
+        case "replaceAgents":
+            return { ...state, agents: action.agents };
+        default:
+            return state;
+    }
+}
+export function createConversationState(partial = {}) {
+    return {
+        agents: {},
+        conversations: [],
+        messages: {},
+        drafts: {},
+        activeId: null,
+        query: "",
+        persistError: null,
+        ...partial,
+    };
+}
+export function isConversationStreaming(state, id) {
+    return (state.messages[id] ?? []).some((m) => m.role === "assistant" && m.state === "streaming" && m.requestId !== undefined);
+}
+export function inFlightRequestIds(state, id) {
+    return (state.messages[id] ?? [])
+        .filter((m) => m.state === "streaming" && m.requestId !== undefined)
+        .map((m) => m.requestId);
+}

package/lib/domain/selection-actions.d.ts

@@ -0,0 +1,13 @@
+import type { SelectionActionId, SelectionActionPayload, SelectionActionSpec, SelectionFacts, SelectionScaffold } from "../types/selection";
+import type { SelectionTarget } from "../types/callbacks";
+export declare const MIN_SELECTION_LENGTH = 2;
+export declare const MAX_SELECTION_LENGTH = 600;
+export declare function normalizeSelectedText(raw: string): string;
+export declare function selectionLengthOk(text: string): boolean;
+export declare function resolveSelection(facts: SelectionFacts): SelectionTarget | null;
+export declare function selectionActionsFor(target: SelectionTarget | null, options: {
+    canFavorite: boolean;
+}): SelectionActionSpec[];
+export declare function quoteFragment(text: string): string;
+export declare function buildScaffold(kind: SelectionScaffold, text: string): string;
+export declare function selectionActionPayload(action: SelectionActionId, target: SelectionTarget): SelectionActionPayload | null;

package/lib/domain/selection-actions.js

@@ -0,0 +1,56 @@
+export const MIN_SELECTION_LENGTH = 2;
+export const MAX_SELECTION_LENGTH = 600;
+export function normalizeSelectedText(raw) {
+    return raw.replace(/\r\n?/g, "\n").trim();
+}
+export function selectionLengthOk(text) {
+    return text.length >= MIN_SELECTION_LENGTH && text.length <= MAX_SELECTION_LENGTH;
+}
+export function resolveSelection(facts) {
+    const text = normalizeSelectedText(facts.raw);
+    if (facts.blocked)
+        return null;
+    if (facts.bubbleRole !== "assistant")
+        return null;
+    if (!selectionLengthOk(text))
+        return null;
+    const agentId = facts.agentId && facts.agentId !== "none" ? facts.agentId : null;
+    return { text, agentId };
+}
+export function selectionActionsFor(target, options) {
+    const actions = [
+        { id: "copy", label: "复制" },
+        { id: "addToConversation", label: "添加到对话" },
+        { id: "followup", label: "深入追问" },
+        { id: "breakdown", label: "拆解" },
+    ];
+    if (options.canFavorite && target && target.agentId !== null) {
+        actions.push({ id: "favorite", label: "收藏" });
+    }
+    return actions;
+}
+export function quoteFragment(text) {
+    return text
+        .split("\n")
+        .map((line) => `> ${line}`)
+        .join("\n");
+}
+const SCAFFOLD_PROMPTS = {
+    followup: "请就上面这段继续深入：补充前提、细节与边界情况。",
+    breakdown: "请把上面这段拆解成可执行的步骤。",
+};
+export function buildScaffold(kind, text) {
+    return `${quoteFragment(text)}\n\n${SCAFFOLD_PROMPTS[kind]}\n`;
+}
+export function selectionActionPayload(action, target) {
+    if (action === "favorite") {
+        if (target.agentId == null)
+            return null;
+        return { kind: "favorite", agentId: target.agentId, content: target.text };
+    }
+    if (action === "copy") {
+        return { kind: "copy", text: target.text };
+    }
+    const scaffold = buildScaffold(action === "addToConversation" ? "followup" : action, target.text);
+    return scaffold.length > 0 ? { kind: "insert", text: scaffold } : null;
+}

package/lib/domain/selection-gates.d.ts

@@ -0,0 +1,6 @@
+import type { ChatMessage } from "../types/message";
+import type { SelectionCapabilities } from "../types/selection";
+export declare function toggleId(ids: readonly string[], id: string): string[];
+export declare function selectedMessages(messages: readonly ChatMessage[], ids: readonly string[]): ChatMessage[];
+export declare function capabilitiesOf(messages: readonly ChatMessage[], ids: readonly string[]): SelectionCapabilities;
+export declare function composeCopyText(picked: readonly ChatMessage[]): string;

package/lib/domain/selection-gates.js

@@ -0,0 +1,36 @@
+export function toggleId(ids, id) {
+    return ids.includes(id) ? ids.filter((x) => x !== id) : [...ids, id];
+}
+export function selectedMessages(messages, ids) {
+    const set = new Set(ids);
+    return messages.filter((m) => set.has(m.id));
+}
+export function capabilitiesOf(messages, ids) {
+    const picked = selectedMessages(messages, ids);
+    const reason = {};
+    if (picked.length === 0) {
+        return {
+            copy: false,
+            remove: false,
+            reason: {
+                copy: "先选中至少一条消息",
+                remove: "先选中至少一条消息",
+            },
+        };
+    }
+    const copy = picked.some((m) => m.text.trim().length > 0);
+    if (!copy)
+        reason.copy = "选中消息均无可复制正文";
+    const allHaveSource = picked.every((m) => Boolean(m.sourceId));
+    const remove = allHaveSource;
+    if (!allHaveSource) {
+        reason.remove = "部分消息缺后端身份（本地消息），删除会留不可撤销的洞";
+    }
+    return { copy, remove, reason };
+}
+export function composeCopyText(picked) {
+    return picked
+        .map((m) => m.text.trim())
+        .filter((t) => t.length > 0)
+        .join("\n\n");
+}

package/lib/domain/slash-commands.d.ts

@@ -0,0 +1,16 @@
+import type { SlashCommand, SlashCommandContext, SlashPickPlan } from "../types/composer";
+export type { SlashCommand, SlashCommandContext, SlashPickPlan };
+export declare const BUILT_IN_SLASH_COMMANDS: readonly SlashCommand[];
+export declare function filterSlashCommands(commands: readonly SlashCommand[], query: string): SlashCommand[];
+export declare function findSlashCommand(commands: readonly SlashCommand[], id: string): SlashCommand | undefined;
+export declare function mergeSlashCommands(builtin: readonly SlashCommand[], ...extras: ReadonlyArray<readonly SlashCommand[]>): SlashCommand[];
+export declare function expandCommandTemplate(template: string, args: string): string;
+export declare function expandSlashDraft(commands: readonly SlashCommand[], draft: string): string | null;
+export declare function planSlashCommandPick(params: {
+    value: string;
+    tokenStart: number;
+    caret: number;
+    trigger: string;
+    template: string;
+}): SlashPickPlan;
+export declare function slashCommandAvailable(command: SlashCommand, ctx: SlashCommandContext): boolean;