@co0ontty/wand 4.40.5 → 4.41.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "f55ec99c626885ac5e3467ecd422b3414f596e4a",
-  "builtAt": "2026-08-09T07:29:23.083Z",
-  "version": "4.40.5",
+  "commit": "86d7332e9d197173cbabe647abdbbd7c50433814",
+  "builtAt": "2026-08-09T08:05:58.283Z",
+  "version": "4.41.0",
   "channel": "stable"
 }

package/dist/git-worktree.d.ts

@@ -32,7 +32,13 @@ export declare class WorktreeMergeError extends Error {
     readonly result?: Partial<WorktreeMergeResult> | undefined;
     constructor(code: string, message: string, result?: Partial<WorktreeMergeResult> | undefined);
 }
+export interface WorktreeTargetBranch {
+    repoRoot: string;
+    targetBranch: string;
+}
 export declare function getWorktreeMergeErrorCode(error: unknown): string | undefined;
+/** Resolve one stable merge target for every worktree belonging to a project. */
+export declare function resolveWorktreeTargetBranchAsync(cwd: string, gitTimeoutMs?: number): Promise<WorktreeTargetBranch>;
 /** Async HTTP-facing worktree check; commands remain deliberately serial. */
 export declare function checkSessionWorktreeMergeabilityAsync(options: WorktreeMergeOptions): Promise<WorktreeMergeCheckResult>;
 export declare function cleanupSessionWorktreeAsync(options: WorktreeOperationOptions): Promise<boolean>;

package/dist/git-worktree.js

@@ -91,7 +91,7 @@ function ensureWorktreePath(worktree) {
     }
     return worktreePath;
 }
-function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
+function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts, commits) {
     const ok = !hasDirtyChanges && aheadCount > 0 && !hasConflicts;
     return {
         ok,
@@ -103,6 +103,7 @@ function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
         aheadCount,
         hasConflicts,
         recommendedAction: hasConflicts ? "resolve-conflict" : aheadCount > 0 ? "merge" : "noop",
+        commits,
         reason: hasDirtyChanges
             ? "Worktree 中仍有未提交改动。"
             : aheadCount <= 0
@@ -163,12 +164,22 @@ async function getDefaultBaseBranchAsync(repoRoot, timeoutMs) {
         current = await runWorktreeGitAsync(["branch", "--show-current"], repoRoot, timeoutMs) || "master";
     }
     catch { /* fallback */ }
-    for (const candidate of ["master", "main", current]) {
+    for (const candidate of ["main", "master", current]) {
         if (candidate && await refExistsAsync(repoRoot, candidate, timeoutMs))
             return candidate;
     }
     return "master";
 }
+/** Resolve one stable merge target for every worktree belonging to a project. */
+export async function resolveWorktreeTargetBranchAsync(cwd, gitTimeoutMs) {
+    const timeoutMs = resolveGitTimeout(gitTimeoutMs);
+    const checkoutRoot = await getRepoRootFromWorktreeAsync(path.resolve(cwd), timeoutMs);
+    const repoRoot = await getMainRepoRootAsync(checkoutRoot, timeoutMs);
+    return {
+        repoRoot,
+        targetBranch: await getDefaultBaseBranchAsync(repoRoot, timeoutMs),
+    };
+}
 async function getMainRepoContextAsync(options) {
     const gitTimeoutMs = resolveGitTimeout(options.gitTimeoutMs);
     const worktreePath = ensureWorktreePath(options.worktree);
@@ -200,6 +211,24 @@ async function checkConflictsAsync(context) {
         return true;
     }
 }
+async function listAheadCommitsAsync(context) {
+    const output = await runWorktreeGitAsync([
+        "log",
+        "--max-count=50",
+        "--format=%H%x1f%h%x1f%s%x1e",
+        `${context.targetBranch}..${context.sourceBranch}`,
+    ], context.repoRoot, context.gitTimeoutMs);
+    return output
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const [hash = "", shortHash = "", ...subjectParts] = record.split("\x1f");
+        if (!hash)
+            return [];
+        return [{ hash, shortHash: shortHash || hash.slice(0, 7), subject: subjectParts.join("\x1f") }];
+    });
+}
 async function captureCheckoutStateAsync(context) {
     let branch = null;
     try {
@@ -295,7 +324,8 @@ export async function checkSessionWorktreeMergeabilityAsync(options) {
     const dirty = (await runWorktreeGitAsync(["status", "--porcelain"], context.worktreePath, context.gitTimeoutMs)).length > 0;
     const aheadCount = Number.parseInt(await runWorktreeGitAsync(["rev-list", "--count", `${context.targetBranch}..${context.sourceBranch}`], context.repoRoot, context.gitTimeoutMs) || "0", 10) || 0;
     const conflicts = !dirty && aheadCount > 0 ? await checkConflictsAsync(context) : false;
-    return buildCheckResult(context, aheadCount, dirty, conflicts);
+    const commits = aheadCount > 0 ? await listAheadCommitsAsync(context) : [];
+    return buildCheckResult(context, aheadCount, dirty, conflicts, commits);
 }
 export async function cleanupSessionWorktreeAsync(options) {
     return cleanupMergedWorktreeAsync(await getMainRepoContextAsync(options));

package/dist/server-workspace-routes.js

@@ -4,7 +4,7 @@ import { existsSync, statSync } from "node:fs";
 import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { expandHomePath } from "./middleware/path-safety.js";
-import { prepareSessionWorktree } from "./git-worktree.js";
+import { checkSessionWorktreeMergeabilityAsync, prepareSessionWorktree, resolveWorktreeTargetBranchAsync, } from "./git-worktree.js";
 import { runGit } from "./git-utils.js";
 const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
 function parseDefaultProvider(value) {
@@ -42,6 +42,12 @@ function deleteSessions(storage, sessions, sessionIds) {
             storage.deleteSession(sessionId);
     }
 }
+function workspaceWithWorktreeCount(storage, workspace) {
+    const worktreeCount = storage.listWorkspaceTasks(workspace.id)
+        .filter((task) => task.worktree !== null)
+        .length;
+    return { ...workspace, worktreeCount };
+}
 // ── Layout validation / sanitization（前端 PUT 与测试共用）──
 function sanitizePaneTab(value) {
     if (!value || typeof value !== "object")
@@ -155,7 +161,7 @@ export function sanitizeTaskLayout(value) {
 export function registerWorkspaceRoutes(app, storage, sessions) {
     // 列出所有项目（按最近打开排序）
     app.get("/api/workspaces", (_req, res) => {
-        res.json(storage.listWorkspaces());
+        res.json(storage.listWorkspaces().map((workspace) => workspaceWithWorktreeCount(storage, workspace)));
     });
     // 新建项目：名称 + 目录 + 默认 IDE，不启动会话
     app.post("/api/workspaces", asyncRoute(async (req, res) => {
@@ -175,7 +181,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         const defaultProvider = parseDefaultProvider(body.defaultProvider);
         const workspace = storage.createWorkspace({ name, cwd, defaultProvider });
-        res.status(201).json(workspace);
+        res.status(201).json({ ...workspace, worktreeCount: 0 });
     }));
     // 项目详情：meta + 会话 + 布局；访问即更新 lastOpenedAt
     app.get("/api/workspaces/:id", (req, res) => {
@@ -185,7 +191,10 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             return;
         }
         storage.touchWorkspace(workspace.id);
-        res.json({ ...workspace, sessions: storage.listSessionsByWorkspace(workspace.id) });
+        res.json({
+            ...workspaceWithWorktreeCount(storage, workspace),
+            sessions: storage.listSessionsByWorkspace(workspace.id),
+        });
     });
     // 改名 / 目录 / 默认 IDE
     app.patch("/api/workspaces/:id", (req, res) => {
@@ -216,7 +225,8 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
                 patch.defaultProvider = parsed;
         }
         storage.updateWorkspace(existing.id, patch);
-        res.json(storage.getWorkspace(existing.id));
+        const updated = storage.getWorkspace(existing.id);
+        res.json(updated ? workspaceWithWorktreeCount(storage, updated) : null);
     });
     // 删除项目；cascade=true 连带删会话，否则仅解绑
     app.delete("/api/workspaces/:id", (req, res) => {
@@ -269,6 +279,82 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         res.json(storage.listWorkspaceTasks(workspace.id));
     });
+    // 项目级 Worktree 总览：一次解析默认目标分支，再为每个任务读取可合并状态。
+    app.get("/api/workspaces/:id/worktrees", asyncRoute(async (req, res) => {
+        const workspace = storage.getWorkspace(req.params.id);
+        if (!workspace) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        const tasks = storage.listWorkspaceTasks(workspace.id).filter((task) => task.worktree !== null);
+        if (tasks.length === 0) {
+            res.json({ workspaceId: workspace.id, repoRoot: workspace.cwd, targetBranch: "", worktrees: [] });
+            return;
+        }
+        let target;
+        try {
+            target = await resolveWorktreeTargetBranchAsync(workspace.cwd);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法识别项目默认分支。") });
+            return;
+        }
+        const worktrees = await Promise.all(tasks.map(async (task) => {
+            const worktree = task.worktree;
+            try {
+                const inspection = await checkSessionWorktreeMergeabilityAsync({
+                    worktree,
+                    targetBranch: target.targetBranch,
+                });
+                const actionable = inspection.hasUncommittedChanges || inspection.aheadCount > 0;
+                const state = inspection.hasUncommittedChanges
+                    ? "dirty"
+                    : inspection.hasConflicts
+                        ? "conflict"
+                        : inspection.aheadCount > 0
+                            ? "ready"
+                            : "empty";
+                return {
+                    taskId: task.id,
+                    taskName: task.name,
+                    taskStatus: task.status,
+                    branch: worktree.branch,
+                    path: worktree.path,
+                    baseRef: worktree.baseRef ?? "",
+                    state,
+                    actionable,
+                    reason: inspection.reason ?? "",
+                    aheadCount: inspection.aheadCount,
+                    hasUncommittedChanges: inspection.hasUncommittedChanges,
+                    hasConflicts: inspection.hasConflicts,
+                    commits: inspection.commits,
+                };
+            }
+            catch (error) {
+                return {
+                    taskId: task.id,
+                    taskName: task.name,
+                    taskStatus: task.status,
+                    branch: worktree.branch,
+                    path: worktree.path,
+                    baseRef: worktree.baseRef ?? "",
+                    state: "unavailable",
+                    actionable: false,
+                    reason: getErrorMessage(error, "无法读取 Worktree 状态。"),
+                    aheadCount: 0,
+                    hasUncommittedChanges: false,
+                    hasConflicts: false,
+                    commits: [],
+                };
+            }
+        }));
+        res.json({
+            workspaceId: workspace.id,
+            repoRoot: target.repoRoot,
+            targetBranch: target.targetBranch,
+            worktrees,
+        });
+    }));
     // 新建任务：命名 + 创建独立 worktree（非 git 仓库时退化为直接用项目目录）
     app.post("/api/workspaces/:id/tasks", asyncRoute(async (req, res) => {
         const workspace = storage.getWorkspace(req.params.id);

package/dist/types.d.ts

@@ -205,6 +205,11 @@ export interface WorktreeMergeInfo {
     lastError?: string;
     conflict?: boolean;
 }
+export interface WorktreeMergeCommit {
+    hash: string;
+    shortHash: string;
+    subject: string;
+}
 export interface WorktreeMergeCheckResult {
     ok: boolean;
     sourceBranch: string;
@@ -216,6 +221,8 @@ export interface WorktreeMergeCheckResult {
     hasConflicts: boolean;
     recommendedAction: "merge" | "noop" | "resolve-conflict";
     reason?: string;
+    /** Newest-first commit preview for project-level worktree review. */
+    commits: WorktreeMergeCommit[];
 }
 export interface WorktreeMergeResult {
     ok: boolean;