@co0ontty/wand 1.26.0 → 1.29.1

package/dist/git-quick-commit.js

@@ -31,6 +31,38 @@ function getGitErrorMessage(error) {
         return e.message;
     return String(error);
 }
+/** Throws `QuickCommitError` if `cwd` isn't an existing path inside a git work tree. */
+function assertGitWorkTree(cwd) {
+    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");
+    }
+}
+/**
+ * Resolve the remote to push to. Prefers `branch.<name>.remote` config for the
+ * current branch, falls back to `origin`. Never throws.
+ */
+function resolvePushRemote(cwd) {
+    try {
+        const branch = runGit(["branch", "--show-current"], cwd);
+        if (branch) {
+            return runGit(["config", "--get", `branch.${branch}.remote`], cwd) || "origin";
+        }
+    }
+    catch {
+        // ignore — fall through to default
+    }
+    return "origin";
+}
 function unquotePath(raw) {
     if (raw.startsWith("\"") && raw.endsWith("\"")) {
         return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
@@ -141,20 +173,18 @@ 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;
+    let lastCommit;
     if (!initialCommit) {
         try {
             upstream = runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd) || undefined;
-            hasUpstream = !!upstream;
         }
         catch {
-            hasUpstream = false;
+            upstream = undefined;
         }
-        if (hasUpstream) {
+        if (upstream) {
             try {
                 const counts = runGit(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], cwd);
                 const parts = counts.split(/\s+/).filter(Boolean);
@@ -168,13 +198,9 @@ export function getGitStatus(cwd) {
                 }
             }
             catch {
-                // ignore — keep counts undefined
+                // ignore — counts stay 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");
@@ -186,41 +212,10 @@ export function getGitStatus(cwd) {
             // 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
-        }
-    }
+    // NOTE: we intentionally do NOT probe the remote for unpushed tags here.
+    // `ls-remote` is a synchronous network call that can block the event loop
+    // for seconds. The "unpushed tag" UI chip is best-effort and a separate
+    // async endpoint should compute it on demand if reintroduced.
     return {
         isGit: true,
         branch,
@@ -229,12 +224,10 @@ export function getGitStatus(cwd) {
         head,
         repoRoot,
         initialCommit,
-        hasUpstream,
         upstream,
         ahead,
         behind,
         lastCommit,
-        unpushedTagCount,
     };
 }
 export class QuickCommitError extends Error {
@@ -446,27 +439,19 @@ ${diff}`;
  * 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) {
+function doPush(opts) {
+    const { cwd, pushCommits, pushTags } = opts;
     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;
     }
+    const pushRemote = resolvePushRemote(cwd);
     try {
         if (pushCommits) {
             if (hasUpstream) {
@@ -478,7 +463,14 @@ function doPush(cwd, pushCommits, pushTags) {
             pushedCommits = true;
         }
         if (pushTags) {
-            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
+            if (Array.isArray(pushTags)) {
+                for (const name of pushTags) {
+                    runGit(["push", pushRemote, `refs/tags/${name}`], cwd, GIT_PUSH_TIMEOUT_MS);
+                }
+            }
+            else {
+                runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
             pushedTags = true;
         }
         return { pushedCommits, pushedTags };
@@ -489,20 +481,7 @@ function doPush(cwd, pushCommits, pushTags) {
 }
 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
+    assertGitWorkTree(cwd);
     let headHash;
     try {
         headHash = runGit(["rev-parse", "HEAD"], cwd);
@@ -512,7 +491,6 @@ export async function runTagHead(opts) {
     }
     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);
@@ -544,29 +522,9 @@ export async function runTagHead(opts) {
     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);
-        }
+        const outcome = doPush({ cwd, pushCommits: false, pushTags: [tagName] });
+        pushed = outcome.pushedTags;
+        pushError = outcome.error;
     }
     return {
         ok: true,
@@ -577,23 +535,11 @@ export async function runTagHead(opts) {
 }
 export async function runPush(opts) {
     const { cwd, pushCommits = true, pushTags = false } = opts;
-    if (!cwd || !existsSync(cwd)) {
-        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
-    }
+    assertGitWorkTree(cwd);
     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);
+    const outcome = doPush({ cwd, pushCommits, pushTags });
     return {
         ok: !outcome.error,
         pushedCommits: outcome.pushedCommits,
@@ -601,29 +547,85 @@ export async function runPush(opts) {
         error: outcome.error,
     };
 }
-export async function runQuickCommit(opts) {
-    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
-    if (!cwd || !existsSync(cwd)) {
-        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
-    }
-    let isInside;
+/**
+ * 在 commit 父仓库之前，先在每个内部 dirty / untracked 的 submodule 里
+ * 执行一次 `git add -A` + `git commit -m <msg>`，让父仓库的 add -A
+ * 能正确捕捉到新的 submodule 指针。纯指针变化（仅 commitChanged）的
+ * submodule 不会进入这条路径——那种情况父仓库 add 已经够了。
+ *
+ * 任一 submodule 提交失败都会被收集为非致命错误，不阻塞父仓库继续 commit；
+ * 调用方可以在结果里读到具体哪几个 submodule 失败。
+ */
+function commitDirtySubmodules(parentCwd, message) {
+    const commits = [];
+    const errors = [];
+    let porcelain;
     try {
-        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+        porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], parentCwd);
     }
-    catch (error) {
-        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    catch {
+        return { commits, errors };
     }
-    if (isInside !== "true") {
-        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    const entries = parsePorcelainV2(porcelain);
+    for (const entry of entries) {
+        if (!entry.isSubmodule)
+            continue;
+        const state = entry.submoduleState;
+        if (!state)
+            continue;
+        // 只有内部脏 / 未跟踪才需要进入子目录提交；纯指针变化父仓库自己就能 add。
+        if (!state.hasTrackedChanges && !state.hasUntracked)
+            continue;
+        const subCwd = `${parentCwd}/${entry.path}`;
+        if (!existsSync(subCwd)) {
+            errors.push(`submodule ${entry.path} 路径不存在`);
+            continue;
+        }
+        try {
+            runGit(["add", "-A"], subCwd, 5000);
+        }
+        catch (error) {
+            errors.push(`submodule ${entry.path} add 失败：${getGitErrorMessage(error)}`);
+            continue;
+        }
+        // 子仓 add 之后再判断是否真的有 staged 内容：极端情况下 .gitignore 把所有 dirty
+        // 文件都过滤掉了，会得到一个空 diff，此时跳过避免空 commit。
+        let staged;
+        try {
+            staged = runGitAllowEmpty(["diff", "--cached", "--name-only"], subCwd).trim();
+        }
+        catch {
+            staged = "";
+        }
+        if (!staged)
+            continue;
+        try {
+            runGit(["commit", "-m", message], subCwd, 10_000);
+        }
+        catch (error) {
+            errors.push(`submodule ${entry.path} commit 失败：${getGitErrorMessage(error)}`);
+            continue;
+        }
+        let hash = "";
+        try {
+            hash = runGit(["rev-parse", "--short", "HEAD"], subCwd);
+        }
+        catch { /* ignore */ }
+        commits.push({ path: entry.path, hash });
     }
-    // Step 1: stage all
+    return { commits, errors };
+}
+export async function runQuickCommit(opts) {
+    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
+    assertGitWorkTree(cwd);
+    // 先 add 一次让我们能在 collectStagedDiff 看到完整改动（包含 submodule 指针），
+    // AI 生成 message 时也基于这个 staged diff。
     try {
         runGit(["add", "-A"], cwd, 5000);
     }
     catch (error) {
         throw new QuickCommitError(`git add 失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
     }
-    // Step 2: check if anything to commit
     let stagedFiles;
     try {
         stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
@@ -631,10 +633,18 @@ export async function runQuickCommit(opts) {
     catch (error) {
         throw new QuickCommitError(getGitErrorMessage(error), "GIT_DIFF_FAILED");
     }
-    if (!stagedFiles) {
+    // 父仓库本身可能没有 staged 文件，但 submodule 内部有 dirty / untracked——
+    // 此时也应该允许走 submodule 提交流程。
+    let parentHasStaged = stagedFiles.length > 0;
+    let submoduleHasDirty = false;
+    try {
+        const porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], cwd);
+        submoduleHasDirty = parsePorcelainV2(porcelain).some((e) => e.isSubmodule && (e.submoduleState?.hasTrackedChanges || e.submoduleState?.hasUntracked));
+    }
+    catch { /* keep submoduleHasDirty=false */ }
+    if (!parentHasStaged && !submoduleHasDirty) {
         throw new QuickCommitError("没有任何改动可以提交。", "NOTHING_TO_COMMIT");
     }
-    // Step 3: get commit message
     let message;
     if (autoMessage) {
         message = await generateCommitMessage(cwd, language);
@@ -645,7 +655,32 @@ export async function runQuickCommit(opts) {
             throw new QuickCommitError("commit message 不能为空。", "EMPTY_MESSAGE");
         }
     }
-    // Step 4: commit
+    // 先提交 submodule 内部改动；父仓库随后再 add 一次，picks up 新的 submodule 指针。
+    const submoduleOutcome = commitDirtySubmodules(cwd, message);
+    if (submoduleOutcome.commits.length > 0) {
+        try {
+            runGit(["add", "-A"], cwd, 5000);
+        }
+        catch (error) {
+            throw new QuickCommitError(`父仓库 add submodule 指针失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
+        }
+        // 重新评估父仓库是否有 staged 内容：如果 submodule 是新引入的或指针变了，
+        // 这里应当为真；如果完全没变就走 commit --allow-empty 路径不合适，直接报错。
+        try {
+            stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
+            parentHasStaged = stagedFiles.length > 0;
+        }
+        catch { /* keep stale value */ }
+    }
+    if (!parentHasStaged) {
+        // submodule 都提交了但父仓库还是没有 staged —— 通常意味着 .gitmodules 没动
+        // 而 submodule 指针被 ignore（罕见配置）。这种情况返回成功，但用 SUBMODULE_ONLY
+        // 的语义；上层 UI 可以决定是否继续 push。这里保持向后兼容，沿用 commit 路径
+        // 但用 --allow-empty 会有副作用，干脆抛 NOTHING_TO_COMMIT。
+        throw new QuickCommitError(submoduleOutcome.commits.length > 0
+            ? `已提交 ${submoduleOutcome.commits.length} 个 submodule，但父仓库没有改动可提交。`
+            : "没有任何改动可以提交。", "NOTHING_TO_COMMIT");
+    }
     try {
         runGit(["commit", "-m", message], cwd, 10_000);
     }
@@ -659,10 +694,7 @@ export async function runQuickCommit(opts) {
     catch {
         commitHash = "";
     }
-    // Step 5: tag
-    // - explicit `tag` wins
-    // - if `tag` is empty and `autoTag` is on, ask Claude to generate one
-    // - otherwise no tag
+    // Tag: explicit `tag` wins; if empty + autoTag, ask Claude; otherwise skip.
     let tagName = (tag || "").trim();
     if (!tagName && autoTag) {
         tagName = await generateTagAfterCommit(cwd, language, message);
@@ -675,11 +707,15 @@ export async function runQuickCommit(opts) {
             throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
         }
     }
-    // Step 6: push
     let pushed = false;
     let pushError;
     if (push) {
-        const outcome = doPush(cwd, true, !!tagName);
+        const outcome = doPush({
+            cwd,
+            pushCommits: true,
+            // Push only the freshly-created tag — avoids surprising users by pushing stale local tags.
+            pushTags: tagName ? [tagName] : false,
+        });
         pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true);
         pushError = outcome.error;
     }
@@ -689,5 +725,6 @@ export async function runQuickCommit(opts) {
         tag: tagName ? { name: tagName } : undefined,
         pushed,
         pushError,
+        submoduleCommits: submoduleOutcome.commits.length > 0 ? submoduleOutcome.commits : undefined,
     };
 }