@co0ontty/wand 1.7.0 → 1.10.0

package/dist/git-worktree.d.ts

@@ -1,4 +1,4 @@
-import { SessionSnapshot } from "./types.js";
+import { SessionSnapshot, WorktreeMergeCheckResult, WorktreeMergeResult } from "./types.js";
 interface WorktreeSetupOptions {
     cwd: string;
     sessionId: string;
@@ -8,5 +8,21 @@ interface WorktreeSetupResult {
     worktreeEnabled: boolean;
     worktree: NonNullable<SessionSnapshot["worktree"]>;
 }
+interface WorktreeOperationOptions {
+    worktree: NonNullable<SessionSnapshot["worktree"]>;
+}
+interface WorktreeMergeOptions extends WorktreeOperationOptions {
+    targetBranch?: string;
+}
+export declare class WorktreeMergeError extends Error {
+    readonly code: string;
+    readonly result?: Partial<WorktreeMergeResult> | undefined;
+    constructor(code: string, message: string, result?: Partial<WorktreeMergeResult> | undefined);
+}
+export declare function getDefaultBaseBranch(repoRoot: string): string;
+export declare function getWorktreeMergeErrorCode(error: unknown): string | undefined;
+export declare function checkSessionWorktreeMergeability(options: WorktreeMergeOptions): WorktreeMergeCheckResult;
+export declare function cleanupSessionWorktree(options: WorktreeOperationOptions): boolean;
+export declare function mergeSessionWorktree(options: WorktreeMergeOptions): WorktreeMergeResult;
 export declare function prepareSessionWorktree(options: WorktreeSetupOptions): WorktreeSetupResult;
 export {};

package/dist/git-worktree.js

@@ -1,6 +1,24 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import path from "node:path";
+const WORKTREE_MERGE_ERROR_CODES = {
+    MISSING: "WORKTREE_MISSING",
+    DIRTY: "WORKTREE_DIRTY",
+    TARGET_MISSING: "TARGET_BRANCH_MISSING",
+    NOTHING_TO_MERGE: "NOTHING_TO_MERGE",
+    CONFLICT: "WORKTREE_MERGE_CONFLICT",
+    CLEANUP_FAILED: "WORKTREE_CLEANUP_FAILED",
+};
+export class WorktreeMergeError extends Error {
+    code;
+    result;
+    constructor(code, message, result) {
+        super(message);
+        this.code = code;
+        this.result = result;
+        this.name = "WorktreeMergeError";
+    }
+}
 function runGit(args, cwd) {
     return execFileSync("git", args, {
         cwd,
@@ -19,6 +37,232 @@ function getCurrentBranch(repoRoot) {
     const branch = runGit(["branch", "--show-current"], repoRoot);
     return branch || "master";
 }
+function isGitCommandError(error) {
+    return error instanceof Error;
+}
+function getGitCommandMessage(error) {
+    if (isGitCommandError(error)) {
+        return error.stderr?.trim() || error.stdout?.trim() || error.message;
+    }
+    return String(error);
+}
+function refExists(repoRoot, ref) {
+    try {
+        runGit(["rev-parse", "--verify", ref], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getRepoRootFromWorktree(worktreePath) {
+    const repoRoot = runGit(["rev-parse", "--show-toplevel"], worktreePath);
+    if (!repoRoot || !existsSync(repoRoot)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 仓库根目录不存在。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return repoRoot;
+}
+function ensureWorktreePath(worktree) {
+    const worktreePath = path.resolve(worktree.path);
+    if (!existsSync(worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 目录不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return worktreePath;
+}
+function getMainRepoRoot(repoRoot) {
+    const commonDir = runGit(["rev-parse", "--git-common-dir"], repoRoot);
+    if (commonDir) {
+        const maybeRoot = path.resolve(repoRoot, commonDir, "..");
+        if (existsSync(maybeRoot)) {
+            return maybeRoot;
+        }
+    }
+    return repoRoot;
+}
+export function getDefaultBaseBranch(repoRoot) {
+    try {
+        const symbolicRef = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], repoRoot);
+        const match = symbolicRef.match(/^refs\/remotes\/origin\/(.+)$/);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    catch {
+        // ignore and fallback below
+    }
+    const candidates = ["master", "main", getCurrentBranch(repoRoot)];
+    for (const candidate of candidates) {
+        if (candidate && refExists(repoRoot, candidate)) {
+            return candidate;
+        }
+    }
+    return "master";
+}
+function getMainRepoContext(options) {
+    const worktreePath = ensureWorktreePath(options.worktree);
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    const repoRoot = getMainRepoRoot(worktreeRepoRoot);
+    const sourceBranch = options.worktree.branch;
+    if (!refExists(repoRoot, sourceBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 分支不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const targetBranch = options.targetBranch?.trim() || getDefaultBaseBranch(repoRoot);
+    if (!refExists(repoRoot, targetBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.TARGET_MISSING, `目标分支不存在：${targetBranch}`, {
+            cleanupDone: false,
+            conflict: false,
+            targetBranch,
+        });
+    }
+    return { repoRoot, worktreePath, sourceBranch, targetBranch };
+}
+function hasUncommittedChanges(worktreePath) {
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    return runGit(["status", "--porcelain"], worktreeRepoRoot).length > 0;
+}
+function getAheadCount(repoRoot, targetBranch, sourceBranch) {
+    const count = runGit(["rev-list", "--count", `${targetBranch}..${sourceBranch}`], repoRoot);
+    return Number.parseInt(count || "0", 10) || 0;
+}
+function checkConflicts(repoRoot, targetBranch, sourceBranch) {
+    try {
+        runGit(["merge-tree", targetBranch, sourceBranch], repoRoot);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function ensureMergeableContext(options) {
+    const context = getMainRepoContext(options);
+    if (hasUncommittedChanges(context.worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.DIRTY, "Worktree 中仍有未提交改动，请先提交后再合并。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (aheadCount <= 0) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.NOTHING_TO_MERGE, "当前 worktree 没有可合并到主分支的新提交。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return { ...context, aheadCount };
+}
+function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
+    const ok = !hasDirtyChanges && aheadCount > 0 && !hasConflicts;
+    return {
+        ok,
+        sourceBranch: context.sourceBranch,
+        targetBranch: context.targetBranch,
+        worktreePath: context.worktreePath,
+        repoRoot: context.repoRoot,
+        hasUncommittedChanges: hasDirtyChanges,
+        aheadCount,
+        hasConflicts,
+        recommendedAction: hasConflicts ? "resolve-conflict" : aheadCount > 0 ? "merge" : "noop",
+        reason: hasDirtyChanges
+            ? "Worktree 中仍有未提交改动。"
+            : aheadCount <= 0
+                ? "当前 worktree 没有可合并的新提交。"
+                : hasConflicts
+                    ? "检测到潜在冲突，请先处理。"
+                    : undefined,
+    };
+}
+function getHeadCommit(repoRoot) {
+    return runGit(["rev-parse", "HEAD"], repoRoot);
+}
+function cleanupMergedWorktree(context) {
+    runGit(["worktree", "remove", context.worktreePath], context.repoRoot);
+    runGit(["branch", "-d", context.sourceBranch], context.repoRoot);
+    return true;
+}
+export function getWorktreeMergeErrorCode(error) {
+    return error instanceof WorktreeMergeError ? error.code : undefined;
+}
+export function checkSessionWorktreeMergeability(options) {
+    const context = getMainRepoContext(options);
+    const hasDirtyChanges = hasUncommittedChanges(context.worktreePath);
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    const hasConflicts = !hasDirtyChanges && aheadCount > 0
+        ? checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch)
+        : false;
+    return buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts);
+}
+export function cleanupSessionWorktree(options) {
+    const context = getMainRepoContext({ worktree: options.worktree });
+    return cleanupMergedWorktree(context);
+}
+export function mergeSessionWorktree(options) {
+    const context = ensureMergeableContext(options);
+    const hasConflicts = checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (hasConflicts) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, "合并检测到冲突，请先手动处理。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    try {
+        runGit(["checkout", context.targetBranch], context.repoRoot);
+        runGit(["merge", "--no-ff", "--no-edit", context.sourceBranch], context.repoRoot);
+    }
+    catch (error) {
+        const message = getGitCommandMessage(error);
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, message || "合并失败，可能存在冲突。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    const mergedAt = new Date().toISOString();
+    const mergeCommit = getHeadCommit(context.repoRoot);
+    try {
+        cleanupMergedWorktree(context);
+        return {
+            ok: true,
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: true,
+            conflict: false,
+        };
+    }
+    catch (error) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CLEANUP_FAILED, getGitCommandMessage(error) || "已合并，但清理 worktree 失败。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+}
 export function prepareSessionWorktree(options) {
     const resolvedCwd = path.resolve(options.cwd);
     const repoRoot = runGit(["rev-parse", "--show-toplevel"], resolvedCwd);

package/dist/resume-policy.d.ts

@@ -1,80 +1,3 @@
 import { ConversationTurn } from "./types.js";
 export declare function hasRealConversationMessages(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasRuntimeConversationSignal(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasStoredConversationHistory(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldBindClaudeSessionId(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldAllowResume(record: {
-    claudeSessionId: string | null | undefined;
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldBackfillFromStoredHistory(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldDisplayResumeAction(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldAutoResumeMessages(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldBackfillMessages(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldPromoteProjectSessionId(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldPromoteStoredSessionId(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldPromoteUiSessionId(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldPromoteResumeSessionId(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasBindableConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasBackfillableConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasUiConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasResumeConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function isRuntimeConversationReady(messages: ConversationTurn[] | undefined): boolean;
-export declare function isStoredConversationReady(messages: ConversationTurn[] | undefined): boolean;
-export declare function isResumeConversationReady(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldBindFromRuntimeMessages(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldAllowUiResume(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldPromoteResumeAction(record: {
-    claudeSessionId: string | null | undefined;
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldBackfillClaudeSessionIdFromDisk(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldUseProjectCandidate(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldResumeProjectCandidate(record: {
-    claudeSessionId: string | null | undefined;
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function shouldBackfillProjectCandidate(record: {
-    messages: ConversationTurn[] | undefined;
-}): boolean;
-export declare function hasMinimumRuntimeConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasMinimumStoredConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasMinimumResumeConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasMinimumBackfillConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasProjectConversationSignal(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasStoredProjectConversationSignal(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasUiProjectConversationSignal(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasResumeProjectConversationSignal(messages: ConversationTurn[] | undefined): boolean;
-export declare function canBindFromProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function canBackfillFromProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function canShowUiProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function canResumeProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldUseRuntimeProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldUseStoredProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldUseUiProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function shouldUseResumeProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasProjectConversationForBinding(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasProjectConversationForBackfill(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasProjectConversationForUi(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasProjectConversationForResume(messages: ConversationTurn[] | undefined): boolean;
-export declare function isBindableProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function isBackfillableProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function isUiProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function isResumeProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasLiveProjectConversation(messages: ConversationTurn[] | undefined): boolean;
-export declare function hasStoredProjectConversation(messages: ConversationTurn[] | undefined): boolean;
 export declare function getResumeCommandSessionId(command: string): string | null;

package/dist/resume-policy.js

@@ -10,168 +10,6 @@ export function hasRealConversationMessages(messages) {
         && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
     return hasUser && hasAssistant;
 }
-export function hasRuntimeConversationSignal(messages) {
-    if (!messages || messages.length === 0) {
-        return false;
-    }
-    const hasUser = messages.some((turn) => turn.role === "user"
-        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
-    const hasAssistant = messages.some((turn) => turn.role === "assistant");
-    return hasUser && hasAssistant;
-}
-export function hasStoredConversationHistory(messages) {
-    return hasRealConversationMessages(messages);
-}
-export function shouldBindClaudeSessionId(record) {
-    return hasRuntimeConversationSignal(record.messages);
-}
-export function shouldAllowResume(record) {
-    return Boolean(record.claudeSessionId) && hasStoredConversationHistory(record.messages);
-}
-export function shouldBackfillFromStoredHistory(record) {
-    return hasStoredConversationHistory(record.messages);
-}
-export function shouldDisplayResumeAction(messages) {
-    return hasStoredConversationHistory(messages);
-}
-export function shouldAutoResumeMessages(messages) {
-    return hasStoredConversationHistory(messages);
-}
-export function shouldBackfillMessages(messages) {
-    return hasStoredConversationHistory(messages);
-}
-export function shouldPromoteProjectSessionId(record) {
-    return shouldBindClaudeSessionId(record);
-}
-export function shouldPromoteStoredSessionId(record) {
-    return shouldBackfillMessages(record.messages);
-}
-export function shouldPromoteUiSessionId(messages) {
-    return shouldDisplayResumeAction(messages);
-}
-export function shouldPromoteResumeSessionId(messages) {
-    return shouldAutoResumeMessages(messages);
-}
-export function hasBindableConversation(messages) {
-    return shouldBindFromRuntimeMessages({ messages: messages ?? [] });
-}
-export function hasBackfillableConversation(messages) {
-    return shouldBackfillMessages(messages);
-}
-export function hasUiConversation(messages) {
-    return shouldPromoteUiSessionId(messages);
-}
-export function hasResumeConversation(messages) {
-    return shouldPromoteResumeSessionId(messages);
-}
-export function isRuntimeConversationReady(messages) {
-    return hasBindableConversation(messages);
-}
-export function isStoredConversationReady(messages) {
-    return hasBackfillableConversation(messages);
-}
-export function isResumeConversationReady(messages) {
-    return hasResumeConversation(messages);
-}
-export function shouldBindFromRuntimeMessages(record) {
-    return isRuntimeConversationReady(record.messages);
-}
-export function shouldAllowUiResume(messages) {
-    return hasUiConversation(messages);
-}
-export function shouldPromoteResumeAction(record) {
-    return shouldAllowResume(record);
-}
-export function shouldBackfillClaudeSessionIdFromDisk(record) {
-    return isStoredConversationReady(record.messages);
-}
-export function shouldUseProjectCandidate(record) {
-    return shouldBindFromRuntimeMessages(record);
-}
-export function shouldResumeProjectCandidate(record) {
-    return shouldPromoteResumeAction(record);
-}
-export function shouldBackfillProjectCandidate(record) {
-    return shouldBackfillClaudeSessionIdFromDisk(record);
-}
-export function hasMinimumRuntimeConversation(messages) {
-    return shouldBindFromRuntimeMessages({ messages: messages ?? [] });
-}
-export function hasMinimumStoredConversation(messages) {
-    return shouldAllowUiResume(messages);
-}
-export function hasMinimumResumeConversation(messages) {
-    return isResumeConversationReady(messages);
-}
-export function hasMinimumBackfillConversation(messages) {
-    return isStoredConversationReady(messages);
-}
-export function hasProjectConversationSignal(messages) {
-    return hasMinimumRuntimeConversation(messages);
-}
-export function hasStoredProjectConversationSignal(messages) {
-    return hasMinimumBackfillConversation(messages);
-}
-export function hasUiProjectConversationSignal(messages) {
-    return hasMinimumStoredConversation(messages);
-}
-export function hasResumeProjectConversationSignal(messages) {
-    return hasMinimumResumeConversation(messages);
-}
-export function canBindFromProjectConversation(messages) {
-    return hasProjectConversationSignal(messages);
-}
-export function canBackfillFromProjectConversation(messages) {
-    return hasStoredProjectConversationSignal(messages);
-}
-export function canShowUiProjectConversation(messages) {
-    return hasUiProjectConversationSignal(messages);
-}
-export function canResumeProjectConversation(messages) {
-    return hasResumeProjectConversationSignal(messages);
-}
-export function shouldUseRuntimeProjectConversation(messages) {
-    return canBindFromProjectConversation(messages);
-}
-export function shouldUseStoredProjectConversation(messages) {
-    return canBackfillFromProjectConversation(messages);
-}
-export function shouldUseUiProjectConversation(messages) {
-    return canShowUiProjectConversation(messages);
-}
-export function shouldUseResumeProjectConversation(messages) {
-    return canResumeProjectConversation(messages);
-}
-export function hasProjectConversationForBinding(messages) {
-    return shouldUseRuntimeProjectConversation(messages);
-}
-export function hasProjectConversationForBackfill(messages) {
-    return shouldUseStoredProjectConversation(messages);
-}
-export function hasProjectConversationForUi(messages) {
-    return shouldUseUiProjectConversation(messages);
-}
-export function hasProjectConversationForResume(messages) {
-    return shouldUseResumeProjectConversation(messages);
-}
-export function isBindableProjectConversation(messages) {
-    return hasProjectConversationForBinding(messages);
-}
-export function isBackfillableProjectConversation(messages) {
-    return hasProjectConversationForBackfill(messages);
-}
-export function isUiProjectConversation(messages) {
-    return hasProjectConversationForUi(messages);
-}
-export function isResumeProjectConversation(messages) {
-    return hasProjectConversationForResume(messages);
-}
-export function hasLiveProjectConversation(messages) {
-    return isBindableProjectConversation(messages);
-}
-export function hasStoredProjectConversation(messages) {
-    return isBackfillableProjectConversation(messages);
-}
 export function getResumeCommandSessionId(command) {
     const match = RESUME_COMMAND_ID_PATTERN.exec(command);
     return match?.[1] ?? null;