@co0ontty/wand 4.68.1 → 4.69.0

package/dist/wand-task-sync.js

@@ -1,103 +1,78 @@
+import { createHash } from "node:crypto";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 import { isSessionProvider } from "./session-provider.js";
 import { isClosedWandTaskStatus, normalizeWandTaskAgentMode } from "./task-types.js";
-const UNNAMED_TASK_NAME = "未命名任务";
-function boardDescriptionFor(task, workspace) {
-    const lines = [`项目：${workspace.name}`];
-    const cwd = task.worktree?.path || task.cwd || workspace.cwd;
-    if (cwd)
-        lines.push(`目录：${cwd}`);
-    if (task.worktree?.branch)
-        lines.push(`分支：${task.worktree.branch}`);
-    return lines.join("\n");
-}
+import { firstLayoutTabId } from "./layout-tree.js";
+/** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
+export const UNNAMED_WORKSPACE_TASK_NAME = "未命名任务";
+/** 历史客户端（Android / 桌面）留空时回传的默认名，同样视为未命名。 */
+const LEGACY_UNNAMED_TASK_NAMES = new Set(["新任务"]);
 export function isUnnamedWorkspaceTaskName(name) {
     const trimmed = name.trim();
-    return !trimmed || trimmed === UNNAMED_TASK_NAME;
-}
-function normalizeTitle(title) {
-    return title.trim().replace(/[。．.!?！？]+$/g, "").replace(/\s+/g, " ");
+    return !trimmed || trimmed === UNNAMED_WORKSPACE_TASK_NAME || LEGACY_UNNAMED_TASK_NAMES.has(trimmed);
 }
-function firstUserMessageText(session) {
+/** Legacy title helper; prompts name sessions, not their containing task. */
+export function boardTitleFromSession(session) {
+    const title = session.title?.trim();
+    if (title && !isUnnamedWorkspaceTaskName(title))
+        return provisionalTaskTitleFromDescription(title);
+    const description = session.description?.trim();
+    if (description)
+        return provisionalTaskTitleFromDescription(description);
     for (const turn of session.messages ?? []) {
         if (turn.role !== "user")
             continue;
-        const text = turn.content
-            .flatMap((block) => block.type === "text" ? [block.text.trim()] : [])
-            .filter(Boolean)
-            .join("\n");
+        const text = turn.content.flatMap((block) => block.type === "text" ? [block.text.trim()] : [])
+            .filter(Boolean).join("\n");
         if (text)
-            return text;
+            return provisionalTaskTitleFromDescription(text);
     }
     return "";
 }
-/** 从未分组会话的标题 / 描述 / 首条用户消息里抽出看板标题。 */
-export function boardTitleFromSession(session) {
-    const title = session.title?.trim() ?? "";
-    if (title && !isUnnamedWorkspaceTaskName(title)) {
-        return provisionalTaskTitleFromDescription(title);
+/**
+ * 自动命名只覆盖「还没有人为名字」的任务：标题来源是 auto，或仍是占位名的历史卡片
+ * （老版本把未命名任务写成了 titleSource=user）。用户在面板 / 侧栏改过名后此处为 false。
+ */
+export function isAutoNameableBoardTask(card) {
+    return card.titleSource === "auto" || isUnnamedWorkspaceTaskName(card.title);
+}
+/** 任务下所有会话（先按看板绑定，再看侧栏 workspace_task_id 兜底），最近的排在前面。 */
+function taskNamingSessions(storage, card) {
+    const sessions = new Map();
+    const add = (session) => {
+        if (session && !sessions.has(session.id))
+            sessions.set(session.id, session);
+    };
+    if (card.workspaceTaskId) {
+        for (const session of storage.listSessionsByWorkspaceTask(card.workspaceTaskId))
+            add(session);
     }
-    const description = session.description?.trim() ?? "";
-    if (description)
-        return provisionalTaskTitleFromDescription(description);
-    const message = firstUserMessageText(session);
-    if (message)
-        return provisionalTaskTitleFromDescription(message);
-    return "";
-}
-function boardDescriptionFromSession(session) {
-    const description = session.description?.trim() ?? "";
-    if (description)
-        return description;
-    const title = session.title?.trim() ?? "";
-    if (title && !isUnnamedWorkspaceTaskName(title))
-        return title;
-    return firstUserMessageText(session);
+    for (const sessionId of storage.listWandTaskSessionIds(card.id))
+        add(storage.getSession(sessionId));
+    return [...sessions.values()].sort((left, right) => (right.startedAt ?? "").localeCompare(left.startedAt ?? ""));
 }
-function pickBestSession(sessions) {
-    if (sessions.length === 0)
-        return null;
-    return sessions.find((session) => boardTitleFromSession(session)) ?? sessions[0] ?? null;
-}
-function isSyncedWorkspaceDescription(description) {
-    const lines = description.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (lines.length === 0)
-        return true;
-    return lines.every((line) => line.startsWith("项目：") || line.startsWith("目录：") || line.startsWith("分支："));
-}
-function bindSessions(storage, taskId, sessionIds) {
-    for (const sessionId of sessionIds) {
-        try {
-            storage.bindWandTaskSession(taskId, sessionId);
-        }
-        catch {
-            // 会话可能已被删；跳过单条，不中断整次对账。
-        }
+/**
+ * 自动命名的输入：任务描述（去掉「项目：/ 目录：/ 分支：」同步元信息）+ 每个会话的可读摘要。
+ * 为空表示这个任务还没有可命名的内容，调用方应保留占位标题。
+ */
+export function taskAutoNameSourceText(storage, card) {
+    const parts = [];
+    for (const line of card.description.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || /^(?:项目|目录|分支)[：:]/.test(trimmed))
+            continue;
+        parts.push(trimmed);
     }
+    for (const session of taskNamingSessions(storage, card)) {
+        const candidate = boardTitleFromSession(session);
+        if (candidate)
+            parts.push(candidate);
+    }
+    return parts.join("\n").slice(0, 4_000);
 }
-function findBoardTaskByTitle(tasks, title, workspaceId) {
-    const needle = normalizeTitle(title);
-    if (!needle)
-        return null;
-    const sameWorkspace = tasks.filter((task) => (task.workspaceId ?? "") === (workspaceId ?? "")
-        && normalizeTitle(task.title) === needle);
-    if (sameWorkspace[0])
-        return sameWorkspace[0];
-    return tasks.find((task) => normalizeTitle(task.title) === needle) ?? null;
-}
-function promoteUngroupedCard(storage, card, patch) {
-    const nextTitle = patch.title?.trim() && isUnnamedWorkspaceTaskName(card.title) ? patch.title.trim() : card.title;
-    const nextDescription = patch.description?.trim() && isSyncedWorkspaceDescription(card.description)
-        ? patch.description.trim()
-        : card.description;
-    return storage.updateWandTask(card.id, {
-        title: nextTitle,
-        titleSource: nextTitle !== card.title ? "auto" : card.titleSource,
-        description: nextDescription,
-        status: isClosedWandTaskStatus(card.status) ? card.status : "doing",
-        workspaceId: patch.workspaceId !== undefined ? patch.workspaceId : card.workspaceId,
-        workspaceTaskId: patch.workspaceTaskId !== undefined ? patch.workspaceTaskId : card.workspaceTaskId,
-    }) ?? card;
+/** 输入指纹：内容没变就没必要再总结一次，也避免自动标题与模型结果来回震荡。 */
+export function taskAutoNameSignature(source) {
+    return createHash("sha1").update(source).digest("hex");
 }
 function agentFromSession(session) {
     if (!isSessionProvider(session.provider))
@@ -110,149 +85,163 @@ function agentFromSession(session) {
         mode: normalizeWandTaskAgentMode(session.provider, session.mode),
     };
 }
-/** 侧栏工作任务与看板卡片对账：已关联则复用，同项目同名未关联则挂上，否则新建。 */
-export function ensureBoardTaskForWorkspaceTask(storage, task, workspace) {
-    const linked = storage.getWandTaskByWorkspaceTaskId(task.id);
-    if (linked)
-        return linked;
-    // 未命名侧栏任务在会话树里并进「未分组终端」；等同步函数根据会话内容补卡片。
-    if (isUnnamedWorkspaceTaskName(task.name))
-        return null;
-    const reusable = storage.findUnlinkedWandTask(workspace.id, task.name);
-    if (reusable) {
-        return storage.updateWandTask(reusable.id, {
-            workspaceTaskId: task.id,
-            workspaceId: workspace.id,
-            ...(task.milestoneId ? { milestoneId: task.milestoneId } : {}),
-        }) ?? reusable;
-    }
+/** Identity is the task id, never its title. Same-named tasks stay independent. */
+export function ensureBoardTaskForWorkspaceTask(storage, task, workspace, options = {}) {
+    const existing = storage.getWandTaskByWorkspaceTaskId(task.id);
+    if (existing)
+        return existing;
     return storage.createWandTask({
-        workspaceId: workspace.id,
+        workspaceId: workspace.kind === "global" ? null : workspace.id,
         workspaceTaskId: task.id,
         title: task.name,
-        description: boardDescriptionFor(task, workspace),
-        status: task.status === "done" ? "done" : "doing",
+        // 占位名（未命名任务 / 新任务 / 空）走自动命名；用户填过名就是 user，永不被模型覆盖。
+        titleSource: options.titleSource ?? (isUnnamedWorkspaceTaskName(task.name) ? "auto" : "user"),
+        description: "",
+        status: task.status === "done" ? "done" : "todo",
         milestoneId: task.milestoneId ?? null,
     });
 }
-/**
- * 把历史未分组会话补到看板：用会话标题/首条消息当标题，绑上会话，放进「进行中」。
- * 幂等，打开看板列表时调用。
- */
-export function syncUngroupedSessionsToBoard(storage) {
-    const boardTasks = storage.listWandTasks();
-    const bound = new Set(storage.listBoundWandTaskSessionIds());
-    for (const workspace of storage.listWorkspaces()) {
-        for (const task of storage.listWorkspaceTasks(workspace.id)) {
-            const sessions = storage.listSessionsByWorkspaceTask(task.id);
-            if (!isUnnamedWorkspaceTaskName(task.name)) {
-                let card = ensureBoardTaskForWorkspaceTask(storage, task, workspace);
-                if (card && !card.agent) {
-                    const agent = sessions.map(agentFromSession).find((value) => value !== null);
-                    if (agent)
-                        card = storage.updateWandTask(card.id, { agent }) ?? card;
+/** A board task always has a sidebar container, even before its first session. */
+export function ensureWorkspaceTaskForBoardTask(storage, card) {
+    const existing = card.workspaceTaskId ? storage.getWorkspaceTask(card.workspaceTaskId) : null;
+    if (existing)
+        return existing;
+    const workspace = card.workspaceId ? storage.getWorkspace(card.workspaceId) : storage.ensureGlobalWorkspace();
+    if (!workspace)
+        throw new Error("任务所属工作区不存在。");
+    const task = storage.createWorkspaceTask({
+        workspaceId: workspace.id,
+        name: card.title,
+        status: isClosedWandTaskStatus(card.status) ? "done" : "active",
+        milestoneId: card.milestoneId,
+    });
+    storage.updateWandTask(card.id, { workspaceTaskId: task.id });
+    return task;
+}
+function removeSessionTab(node, sessionId) {
+    if (node.type === "split")
+        return {
+            ...node,
+            children: [removeSessionTab(node.children[0], sessionId), removeSessionTab(node.children[1], sessionId)],
+        };
+    const activeId = node.tabs[node.active]?.id;
+    const tabs = node.tabs.filter((tab) => tab.kind !== "session" || tab.sessionId !== sessionId);
+    const active = tabs.findIndex((tab) => tab.id === activeId);
+    return { ...node, tabs, active: active >= 0 ? active : Math.min(node.active, Math.max(0, tabs.length - 1)) };
+}
+/** Remove stale source tabs so opening an old task cannot re-open a moved session. */
+function detachSessionLayout(storage, task, sessionId) {
+    if (!task.layout) {
+        storage.saveWorkspaceTaskLayout(task.id, null);
+        return;
+    }
+    const windows = task.layout.windows.map((window) => {
+        const layout = removeSessionTab(window.layout, sessionId);
+        return { ...window, layout, activeTabId: firstLayoutTabId(layout) };
+    });
+    storage.saveWorkspaceTaskLayout(task.id, { ...task.layout, windows });
+}
+/** Atomic exclusive ownership change. Never changes cwd, messages, or execution state. */
+export function moveSessionToWorkspaceTask(storage, sessionId, taskId) {
+    storage.transaction(() => {
+        const session = storage.getSession(sessionId);
+        if (!session)
+            throw new Error("未找到该会话。");
+        const target = taskId ? storage.getWorkspaceTask(taskId) : null;
+        if (taskId && !target)
+            throw new Error("未找到目标任务。");
+        const source = session.workspaceTaskId ? storage.getWorkspaceTask(session.workspaceTaskId) : null;
+        if (source && source.id !== target?.id)
+            detachSessionLayout(storage, source, sessionId);
+        // Explicit task metadata is owned by storage, not by a runner checkpoint.
+        storage.setSessionWorkspaceTaskId(sessionId, target?.id ?? null);
+        for (const card of storage.listWandTasks()) {
+            if (card.workspaceTaskId !== target?.id)
+                storage.unbindWandTaskSession(card.id, sessionId);
+        }
+        if (!target)
+            return;
+        const workspace = storage.getWorkspace(target.workspaceId);
+        if (!workspace)
+            throw new Error("目标工作区不存在。");
+        storage.setSessionWorkspaceId(sessionId, workspace.id);
+        const card = ensureBoardTaskForWorkspaceTask(storage, target, workspace);
+        const newlyBound = !storage.listWandTaskSessionIds(card.id).includes(sessionId);
+        storage.bindWandTaskSession(card.id, sessionId);
+        if (newlyBound && card.status === "todo")
+            storage.updateWandTask(card.id, { status: "doing" });
+    });
+}
+/** Reconcile legacy records by explicit ids. Unassigned sessions remain unassigned. */
+export function syncSidebarTasksFromBoard(storage) {
+    storage.transaction(() => {
+        for (const card of storage.listWandTasks()) {
+            // Deleted sidebar tasks leave an archived card, not a resurrected container.
+            if (!card.workspaceTaskId && card.status === "archived")
+                continue;
+            const task = ensureWorkspaceTaskForBoardTask(storage, card);
+            for (const sessionId of storage.listWandTaskSessionIds(card.id)) {
+                const session = storage.getSession(sessionId);
+                if (!session)
+                    continue;
+                if (session.workspaceTaskId && session.workspaceTaskId !== task.id) {
+                    storage.unbindWandTaskSession(card.id, sessionId);
                 }
-                if (card) {
-                    bindSessions(storage, card.id, sessions.map((session) => session.id));
-                    for (const session of sessions)
-                        bound.add(session.id);
+                else if (session.workspaceTaskId !== task.id || session.workspaceId !== task.workspaceId) {
+                    storage.setSessionWorkspaceTaskId(sessionId, task.id);
+                    storage.setSessionWorkspaceId(sessionId, task.workspaceId);
                 }
-                continue;
-            }
-            const best = pickBestSession(sessions);
-            const title = best ? boardTitleFromSession(best) : "";
-            if (!best || !title)
-                continue;
-            const description = boardDescriptionFromSession(best);
-            let card = storage.getWandTaskByWorkspaceTaskId(task.id)
-                ?? findBoardTaskByTitle(boardTasks, title, workspace.id);
-            if (!card) {
-                card = storage.createWandTask({
-                    workspaceId: workspace.id,
-                    workspaceTaskId: task.id,
-                    title,
-                    titleSource: "auto",
-                    description,
-                    status: "doing",
-                    // 未命名任务建立板卡时才补上：建任务时选的里程碑不能丢。
-                    milestoneId: task.milestoneId ?? null,
-                });
-                boardTasks.push(card);
             }
-            else {
-                card = promoteUngroupedCard(storage, card, {
-                    title,
-                    description,
-                    workspaceId: workspace.id,
-                    workspaceTaskId: task.id,
-                });
-                if (!card.milestoneId && task.milestoneId) {
-                    card = storage.updateWandTask(card.id, { milestoneId: task.milestoneId }) ?? card;
+        }
+    });
+}
+export function syncUngroupedSessionsToBoard(storage) {
+    syncSidebarTasksFromBoard(storage);
+    storage.transaction(() => {
+        for (const workspace of storage.listWorkspaces()) {
+            for (const task of storage.listWorkspaceTasks(workspace.id)) {
+                let card = ensureBoardTaskForWorkspaceTask(storage, task, workspace);
+                const sessions = storage.listSessionsByWorkspaceTask(task.id);
+                const agent = sessions.map(agentFromSession).find((value) => value !== null);
+                const bound = new Set(storage.listWandTaskSessionIds(card.id));
+                const started = card.status === "todo" && sessions.some((session) => !bound.has(session.id));
+                if ((!card.agent && agent) || started) {
+                    card = storage.updateWandTask(card.id, {
+                        ...(!card.agent && agent ? { agent } : {}),
+                        ...(started ? { status: "doing" } : {}),
+                    }) ?? card;
                 }
+                for (const session of sessions)
+                    storage.bindWandTaskSession(card.id, session.id);
             }
-            bindSessions(storage, card.id, sessions.map((session) => session.id));
-            for (const session of sessions)
-                bound.add(session.id);
-        }
-    }
-    for (const session of storage.loadSessions()) {
-        if (bound.has(session.id))
-            continue;
-        if (session.workspaceTaskId)
-            continue;
-        const title = boardTitleFromSession(session);
-        if (!title)
-            continue;
-        let card = findBoardTaskByTitle(boardTasks, title, session.workspaceId ?? null);
-        if (!card) {
-            card = storage.createWandTask({
-                workspaceId: session.workspaceId ?? null,
-                title,
-                titleSource: "auto",
-                description: boardDescriptionFromSession(session),
-                status: "doing",
-            });
-            boardTasks.push(card);
-        }
-        else if (!isClosedWandTaskStatus(card.status)) {
-            card = promoteUngroupedCard(storage, card, {
-                title,
-                description: boardDescriptionFromSession(session),
-                workspaceId: session.workspaceId ?? card.workspaceId,
-            });
         }
-        bindSessions(storage, card.id, [session.id]);
-        bound.add(session.id);
-    }
-}
-function closeLinkedWorkspaceTask(storage, workspaceTaskId) {
-    if (!workspaceTaskId)
-        return;
-    const workspaceTask = storage.getWorkspaceTask(workspaceTaskId);
-    if (workspaceTask && workspaceTask.status !== "done") {
-        storage.updateWorkspaceTask(workspaceTask.id, { status: "done" });
-    }
+    });
 }
-/** 看板确认/归档时，把关联的侧栏工作任务标成 done（不删会话）。 */
+/** Status and title projection is centralized in the storage writer. */
 export function syncClosedBoardTask(storage, task) {
-    if (!isClosedWandTaskStatus(task.status))
-        return;
-    closeLinkedWorkspaceTask(storage, task.workspaceTaskId);
+    if (isClosedWandTaskStatus(task.status) && task.workspaceTaskId) {
+        storage.updateWorkspaceTask(task.workspaceTaskId, { status: "done" });
+    }
 }
-/** 看板归档：卡片进入归档目录，并同步把关联的侧栏工作任务标成 done（不删会话）。 */
 export function archiveBoardTask(storage, id) {
-    const current = storage.getWandTask(id);
-    if (!current)
-        return null;
-    const archived = storage.updateWandTask(id, { status: "archived" });
-    if (archived)
-        closeLinkedWorkspaceTask(storage, archived.workspaceTaskId);
-    return archived;
+    return storage.updateWandTask(id, { status: "archived" });
+}
+/**
+ * 归档侧栏任务是软删除：终端继续运行、worktree 与布局都保留，只有看板卡片进入
+ * 归档文件夹、侧栏不再显示。恢复方式是看板里把卡片拖回任一列（或右键恢复）。
+ */
+export function archiveWorkspaceTask(storage, task) {
+    return storage.transaction(() => {
+        const card = storage.getWandTaskByWorkspaceTaskId(task.id);
+        // 先归档卡片，再把侧栏任务标成已完成：反向投影见到 archived 就不会降级成 done。
+        if (card)
+            storage.updateWandTask(card.id, { status: "archived" });
+        storage.updateWorkspaceTask(task.id, { status: "done" });
+        return card ? storage.getWandTask(card.id) : null;
+    });
 }
-/** 侧栏工作任务完成/删除时，把对应看板卡片标成已完成；已归档的保持归档。 */
 export function archiveBoardTaskForWorkspaceTask(storage, workspaceTaskId) {
     const linked = storage.getWandTaskByWorkspaceTaskId(workspaceTaskId);
-    if (!linked || isClosedWandTaskStatus(linked.status))
-        return;
-    storage.updateWandTask(linked.id, { status: "done" });
+    if (linked && !isClosedWandTaskStatus(linked.status))
+        storage.updateWandTask(linked.id, { status: "done" });
 }