@co0ontty/wand 1.25.5 → 1.26.0

package/dist/git-quick-commit.d.ts

@@ -1,4 +1,4 @@
-import { GitStatusResult, QuickCommitResult } from "./types.js";
+import { GitStatusResult, PushResult, QuickCommitResult, TagHeadResult } from "./types.js";
 export declare function getGitStatus(cwd: string): GitStatusResult;
 interface QuickCommitOptions {
     cwd: string;
@@ -20,5 +20,21 @@ export interface GenerateCommitMessageResult {
     suggestedTag?: string;
 }
 export declare function generateCommitMessageOnly(cwd: string, language: string): Promise<GenerateCommitMessageResult>;
+interface TagHeadOptions {
+    cwd: string;
+    language: string;
+    /** Explicit tag name. If empty and `autoTag` is true, ask Claude to generate one. */
+    tag?: string;
+    autoTag?: boolean;
+    /** Push only this tag to its upstream remote after creating it. */
+    push?: boolean;
+}
+export declare function runTagHead(opts: TagHeadOptions): Promise<TagHeadResult>;
+interface PushOptions {
+    cwd: string;
+    pushCommits?: boolean;
+    pushTags?: boolean;
+}
+export declare function runPush(opts: PushOptions): Promise<PushResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export {};

package/dist/git-quick-commit.js

@@ -141,6 +141,86 @@ export function getGitStatus(cwd) {
     }
     const allEntries = parsePorcelainV2(porcelain);
     const files = allEntries.slice(0, MAX_FILE_ENTRIES);
+    // Upstream / ahead / behind ──────────────────────────────────────────
+    let hasUpstream = false;
+    let upstream;
+    let ahead;
+    let behind;
+    if (!initialCommit) {
+        try {
+            upstream = runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd) || undefined;
+            hasUpstream = !!upstream;
+        }
+        catch {
+            hasUpstream = false;
+        }
+        if (hasUpstream) {
+            try {
+                const counts = runGit(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], cwd);
+                const parts = counts.split(/\s+/).filter(Boolean);
+                if (parts.length === 2) {
+                    const b = Number.parseInt(parts[0], 10);
+                    const a = Number.parseInt(parts[1], 10);
+                    if (!Number.isNaN(a))
+                        ahead = a;
+                    if (!Number.isNaN(b))
+                        behind = b;
+                }
+            }
+            catch {
+                // ignore — keep counts undefined
+            }
+        }
+    }
+    // HEAD commit info ───────────────────────────────────────────────────
+    let lastCommit;
+    if (!initialCommit) {
+        try {
+            const raw = runGit(["log", "-1", "--pretty=format:%H%x09%h%x09%s"], cwd);
+            const parts = raw.split("\t");
+            if (parts.length >= 3) {
+                lastCommit = { hash: parts[0], shortHash: parts[1], subject: parts.slice(2).join("\t") };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Unpushed tag count (best-effort; remote refs may not be fresh) ─────
+    let unpushedTagCount;
+    if (hasUpstream && upstream) {
+        const slashIdx = upstream.indexOf("/");
+        const remoteName = slashIdx > 0 ? upstream.slice(0, slashIdx) : "origin";
+        try {
+            const localTagsRaw = runGit(["for-each-ref", "--format=%(refname:short)", "refs/tags"], cwd);
+            const localTags = localTagsRaw.split(/\r?\n/).filter((t) => t.trim().length > 0);
+            if (localTags.length === 0) {
+                unpushedTagCount = 0;
+            }
+            else {
+                const remoteTagsRaw = runGit(["ls-remote", "--tags", remoteName], cwd, 3000);
+                const remoteTags = new Set();
+                for (const line of remoteTagsRaw.split(/\r?\n/)) {
+                    // format: <sha>\trefs/tags/<name>{^}? — strip annotated suffix
+                    const tabIdx = line.indexOf("\t");
+                    if (tabIdx === -1)
+                        continue;
+                    const ref = line.slice(tabIdx + 1).trim();
+                    if (!ref.startsWith("refs/tags/"))
+                        continue;
+                    let name = ref.slice("refs/tags/".length);
+                    if (name.endsWith("^{}"))
+                        name = name.slice(0, -3);
+                    if (name)
+                        remoteTags.add(name);
+                }
+                unpushedTagCount = localTags.filter((t) => !remoteTags.has(t)).length;
+            }
+        }
+        catch {
+            // remote unreachable — leave undefined so UI can hide the chip
+        }
+    }
     return {
         isGit: true,
         branch,
@@ -149,6 +229,12 @@ export function getGitStatus(cwd) {
         head,
         repoRoot,
         initialCommit,
+        hasUpstream,
+        upstream,
+        ahead,
+        behind,
+        lastCommit,
+        unpushedTagCount,
     };
 }
 export class QuickCommitError extends Error {
@@ -356,7 +442,165 @@ ${diff}`;
     }
     return suggested;
 }
-// ── Direct git operations ──
+/**
+ * Push current branch (with upstream auto-setup) and/or tags.
+ * Errors are returned via `error` so callers can present partial-success states.
+ */
+function doPush(cwd, pushCommits, pushTags) {
+    let pushedCommits = false;
+    let pushedTags = false;
+    let hasUpstream = false;
+    let pushRemote = "origin";
+    try {
+        runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+        hasUpstream = true;
+        try {
+            const currentBranch = runGit(["branch", "--show-current"], cwd);
+            if (currentBranch) {
+                pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
+            }
+        }
+        catch {
+            pushRemote = "origin";
+        }
+    }
+    catch {
+        hasUpstream = false;
+    }
+    try {
+        if (pushCommits) {
+            if (hasUpstream) {
+                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            else {
+                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            pushedCommits = true;
+        }
+        if (pushTags) {
+            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
+            pushedTags = true;
+        }
+        return { pushedCommits, pushedTags };
+    }
+    catch (error) {
+        return { pushedCommits, pushedTags, error: getGitErrorMessage(error) };
+    }
+}
+export async function runTagHead(opts) {
+    const { cwd, language, tag, autoTag, push } = opts;
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    }
+    if (isInside !== "true") {
+        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    }
+    // Need an existing commit to tag
+    let headHash;
+    try {
+        headHash = runGit(["rev-parse", "HEAD"], cwd);
+    }
+    catch {
+        throw new QuickCommitError("仓库还没有任何 commit，无法打 tag。", "NO_COMMIT");
+    }
+    let tagName = (tag || "").trim();
+    if (!tagName && autoTag) {
+        // Reuse the post-commit generator — it inspects `git show HEAD` directly.
+        let headSubject = "";
+        try {
+            headSubject = runGit(["log", "-1", "--pretty=format:%s"], cwd);
+        }
+        catch {
+            headSubject = "";
+        }
+        tagName = await generateTagAfterCommit(cwd, language, headSubject || "");
+    }
+    if (!tagName) {
+        throw new QuickCommitError("请填写 tag 名称，或开启 AI 生成。", "EMPTY_TAG");
+    }
+    // Refuse to overwrite an existing tag — surface a clear error code.
+    try {
+        runGit(["rev-parse", "--verify", `refs/tags/${tagName}`], cwd);
+        throw new QuickCommitError(`tag \`${tagName}\` 已存在。`, "TAG_EXISTS");
+    }
+    catch (error) {
+        if (error instanceof QuickCommitError)
+            throw error;
+        // not found — good, proceed
+    }
+    try {
+        runGit(["tag", tagName], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
+    }
+    let pushed = false;
+    let pushError;
+    if (push) {
+        let pushRemote = "origin";
+        try {
+            const currentBranch = runGit(["branch", "--show-current"], cwd);
+            if (currentBranch) {
+                try {
+                    pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
+                }
+                catch {
+                    pushRemote = "origin";
+                }
+            }
+        }
+        catch {
+            pushRemote = "origin";
+        }
+        try {
+            // Push just this one tag — cheaper and more targeted than `--tags`.
+            runGit(["push", pushRemote, `refs/tags/${tagName}`], cwd, GIT_PUSH_TIMEOUT_MS);
+            pushed = true;
+        }
+        catch (error) {
+            pushError = getGitErrorMessage(error);
+        }
+    }
+    return {
+        ok: true,
+        tag: { name: tagName, commit: headHash.slice(0, 7) },
+        pushed,
+        pushError,
+    };
+}
+export async function runPush(opts) {
+    const { cwd, pushCommits = true, pushTags = false } = opts;
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    if (!pushCommits && !pushTags) {
+        throw new QuickCommitError("没有要推送的内容。", "NOTHING_TO_PUSH");
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    }
+    if (isInside !== "true") {
+        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    }
+    const outcome = doPush(cwd, pushCommits, pushTags);
+    return {
+        ok: !outcome.error,
+        pushedCommits: outcome.pushedCommits,
+        pushedTags: outcome.pushedTags,
+        error: outcome.error,
+    };
+}
 export async function runQuickCommit(opts) {
     const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
     if (!cwd || !existsSync(cwd)) {
@@ -435,37 +679,9 @@ export async function runQuickCommit(opts) {
     let pushed = false;
     let pushError;
     if (push) {
-        try {
-            let hasUpstream = false;
-            let pushRemote = "origin";
-            try {
-                runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-                hasUpstream = true;
-                try {
-                    const currentBranch = runGit(["branch", "--show-current"], cwd);
-                    if (currentBranch) {
-                        pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
-                    }
-                }
-                catch {
-                    pushRemote = "origin";
-                }
-            }
-            catch {
-                hasUpstream = false;
-            }
-            if (hasUpstream) {
-                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            else {
-                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
-            pushed = true;
-        }
-        catch (error) {
-            pushError = getGitErrorMessage(error);
-        }
+        const outcome = doPush(cwd, true, !!tagName);
+        pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true);
+        pushError = outcome.error;
     }
     return {
         ok: true,

package/dist/server-session-routes.js

@@ -1,7 +1,7 @@
 import express from "express";
 import { SessionInputError } from "./process-manager.js";
 import { checkSessionWorktreeMergeability, cleanupSessionWorktree, getWorktreeMergeErrorCode, mergeSessionWorktree, WorktreeMergeError } from "./git-worktree.js";
-import { getGitStatus, QuickCommitError, runQuickCommit, generateCommitMessageOnly } from "./git-quick-commit.js";
+import { getGitStatus, QuickCommitError, runQuickCommit, runTagHead, runPush, generateCommitMessageOnly, } from "./git-quick-commit.js";
 export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
@@ -388,6 +388,63 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "生成 commit message 失败。") });
         }
     });
+    app.post("/api/sessions/:id/git/tag-head", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runTagHead({
+                cwd: snapshot.cwd,
+                language: config.language ?? "",
+                tag: typeof body.tag === "string" ? body.tag : undefined,
+                autoTag: !!body.autoTag,
+                push: !!body.push,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                const status = error.code === "TAG_EXISTS" ? 409 : 400;
+                res.status(status).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "打 tag 失败。") });
+        }
+    });
+    app.post("/api/sessions/:id/git/push", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runPush({
+                cwd: snapshot.cwd,
+                pushCommits: body.pushCommits !== false,
+                pushTags: !!body.pushTags,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                res.status(400).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "推送失败。") });
+        }
+    });
     app.post("/api/sessions/:id/worktree/cleanup", (req, res) => {
         try {
             const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));

package/dist/types.d.ts

@@ -169,6 +169,22 @@ export interface GitStatusResult {
     repoRoot?: string;
     /** Truthy when the repo has no commits yet (initial state). */
     initialCommit?: boolean;
+    /** Whether current branch has an upstream tracking branch. */
+    hasUpstream?: boolean;
+    /** Upstream branch identifier (e.g. `origin/main`). Only set when `hasUpstream` is true. */
+    upstream?: string;
+    /** Number of local commits not yet on upstream. Only meaningful when `hasUpstream` is true. */
+    ahead?: number;
+    /** Number of upstream commits not yet locally. Only meaningful when `hasUpstream` is true. */
+    behind?: number;
+    /** HEAD commit subject + short hash (handy for "tag the current commit" UX). */
+    lastCommit?: {
+        hash: string;
+        shortHash: string;
+        subject: string;
+    };
+    /** Number of local tags that don't exist on the remote (best-effort, may be undefined if not reachable). */
+    unpushedTagCount?: number;
     error?: string;
 }
 export interface QuickCommitResult {
@@ -184,6 +200,22 @@ export interface QuickCommitResult {
     /** commit 已成功但 push 失败时填入；前端用它显示"已提交但 push 失败"。 */
     pushError?: string;
 }
+export interface TagHeadResult {
+    ok: boolean;
+    tag: {
+        name: string;
+        commit: string;
+    };
+    pushed?: boolean;
+    pushError?: string;
+}
+export interface PushResult {
+    ok: boolean;
+    pushedCommits: boolean;
+    pushedTags: boolean;
+    /** Either operation failed — the other may still have succeeded. */
+    error?: string;
+}
 export interface CommandRequest {
     command: string;
     provider?: SessionProvider;