@codex-infinity/pi-infinity 0.62.1 → 0.62.3

package/dist/core/package-manager.js

@@ -1040,11 +1040,33 @@ export class DefaultPackageManager {
     }
     async getLocalGitUpdateTarget(installedPath) {
         try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmedUpstream = upstream.trim();
+            if (!trimmedUpstream.startsWith("origin/")) {
+                throw new Error(`Unsupported upstream remote: ${trimmedUpstream}`);
+            }
+            const branch = trimmedUpstream.slice("origin/".length);
+            if (!branch) {
+                throw new Error("Missing upstream branch name");
+            }
             const head = await this.runCommandCapture("git", ["rev-parse", "@{upstream}"], {
                 cwd: installedPath,
                 timeoutMs: NETWORK_TIMEOUT_MS,
             });
-            return { ref: "@{upstream}", head };
+            return {
+                ref: "@{upstream}",
+                head,
+                fetchArgs: [
+                    "fetch",
+                    "--prune",
+                    "--no-tags",
+                    "origin",
+                    `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                ],
+            };
         }
         catch {
             await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: installedPath }).catch(() => { });
@@ -1052,7 +1074,29 @@ export class DefaultPackageManager {
                 cwd: installedPath,
                 timeoutMs: NETWORK_TIMEOUT_MS,
             });
-            return { ref: "origin/HEAD", head };
+            const originHeadRef = await this.runCommandCapture("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            }).catch(() => "");
+            const branch = originHeadRef.trim().replace(/^refs\/remotes\/origin\//, "");
+            if (branch) {
+                return {
+                    ref: "origin/HEAD",
+                    head,
+                    fetchArgs: [
+                        "fetch",
+                        "--prune",
+                        "--no-tags",
+                        "origin",
+                        `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                    ],
+                };
+            }
+            return {
+                ref: "origin/HEAD",
+                head,
+                fetchArgs: ["fetch", "--prune", "--no-tags", "origin", "+HEAD:refs/remotes/origin/HEAD"],
+            };
         }
     }
     async getGitUpstreamRef(installedPath) {
@@ -1217,14 +1261,18 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
-        // Fetch latest from remote (handles force-push by getting new history)
-        await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
+        const target = await this.getLocalGitUpdateTarget(targetDir);
+        // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
+        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
         const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        const target = await this.getLocalGitUpdateTarget(targetDir);
-        if (localHead.trim() === target.head.trim()) {
+        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        if (localHead.trim() === refreshedTargetHead.trim()) {
             return;
         }
         await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });