@mariozechner/pi-coding-agent 0.58.4 → 0.60.0

package/dist/core/package-manager.js

@@ -8,6 +8,7 @@ import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { parseGitUrl } from "../utils/git.js";
 const NETWORK_TIMEOUT_MS = 10000;
+const UPDATE_CHECK_CONCURRENCY = 4;
 function isOfflineModeEnabled() {
     const value = process.env.PI_OFFLINE;
     if (!value)
@@ -708,6 +709,62 @@ export class DefaultPackageManager {
             return;
         }
     }
+    async checkForAvailableUpdates() {
+        if (isOfflineModeEnabled()) {
+            return [];
+        }
+        const globalSettings = this.settingsManager.getGlobalSettings();
+        const projectSettings = this.settingsManager.getProjectSettings();
+        const allPackages = [];
+        for (const pkg of projectSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "project" });
+        }
+        for (const pkg of globalSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "user" });
+        }
+        const packageSources = this.dedupePackages(allPackages);
+        const checks = packageSources
+            .filter((entry) => entry.scope !== "temporary")
+            .map((entry) => async () => {
+            const source = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
+            const parsed = this.parseSource(source);
+            if (parsed.type === "local" || parsed.pinned) {
+                return undefined;
+            }
+            if (parsed.type === "npm") {
+                const installedPath = this.getNpmInstallPath(parsed, entry.scope);
+                if (!existsSync(installedPath)) {
+                    return undefined;
+                }
+                const hasUpdate = await this.npmHasAvailableUpdate(parsed, installedPath);
+                if (!hasUpdate) {
+                    return undefined;
+                }
+                return {
+                    source,
+                    displayName: parsed.name,
+                    type: "npm",
+                    scope: entry.scope,
+                };
+            }
+            const installedPath = this.getGitInstallPath(parsed, entry.scope);
+            if (!existsSync(installedPath)) {
+                return undefined;
+            }
+            const hasUpdate = await this.gitHasAvailableUpdate(installedPath);
+            if (!hasUpdate) {
+                return undefined;
+            }
+            return {
+                source,
+                displayName: `${parsed.host}/${parsed.path}`,
+                type: "git",
+                scope: entry.scope,
+            };
+        });
+        const results = await this.runWithConcurrency(checks, UPDATE_CHECK_CONCURRENCY);
+        return results.filter((result) => result !== undefined);
+    }
     async resolvePackageSources(sources, accumulator, onMissing) {
         for (const { pkg, scope } of sources) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
@@ -737,7 +794,8 @@ export class DefaultPackageManager {
             };
             if (parsed.type === "npm") {
                 const installedPath = this.getNpmInstallPath(parsed, scope);
-                const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+                const needsInstall = !existsSync(installedPath) ||
+                    (parsed.pinned && !(await this.installedNpmMatchesPinnedVersion(parsed, installedPath)));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
@@ -863,30 +921,30 @@ export class DefaultPackageManager {
         }
         return { type: "local", path: source };
     }
-    /**
-     * Check if an npm package needs to be updated.
-     * - For unpinned packages: check if registry has a newer version
-     * - For pinned packages: check if installed version matches the pinned version
-     */
-    async npmNeedsUpdate(source, installedPath) {
+    async installedNpmMatchesPinnedVersion(source, installedPath) {
+        const installedVersion = this.getInstalledNpmVersion(installedPath);
+        if (!installedVersion) {
+            return false;
+        }
+        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
+        if (!pinnedVersion) {
+            return true;
+        }
+        return installedVersion === pinnedVersion;
+    }
+    async npmHasAvailableUpdate(source, installedPath) {
         if (isOfflineModeEnabled()) {
             return false;
         }
         const installedVersion = this.getInstalledNpmVersion(installedPath);
-        if (!installedVersion)
-            return true;
-        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
-        if (pinnedVersion) {
-            // Pinned: check if installed matches pinned (exact match for now)
-            return installedVersion !== pinnedVersion;
+        if (!installedVersion) {
+            return false;
         }
-        // Unpinned: check registry for latest version
         try {
             const latestVersion = await this.getLatestNpmVersion(source.name);
             return latestVersion !== installedVersion;
         }
         catch {
-            // If we can't check registry, assume it's fine
             return false;
         }
     }
@@ -912,6 +970,84 @@ export class DefaultPackageManager {
         const data = (await response.json());
         return data.version;
     }
+    async gitHasAvailableUpdate(installedPath) {
+        if (isOfflineModeEnabled()) {
+            return false;
+        }
+        try {
+            const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const remoteHead = await this.getRemoteGitHead(installedPath);
+            return localHead.trim() !== remoteHead.trim();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getRemoteGitHead(installedPath) {
+        const upstreamRef = await this.getGitUpstreamRef(installedPath);
+        if (upstreamRef) {
+            const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", upstreamRef]);
+            const match = remoteHead.match(/^([0-9a-f]{40})\s+/m);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", "HEAD"]);
+        const match = remoteHead.match(/^([0-9a-f]{40})\s+HEAD$/m);
+        if (!match?.[1]) {
+            throw new Error("Failed to determine remote HEAD");
+        }
+        return match[1];
+    }
+    async getGitUpstreamRef(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmed = upstream.trim();
+            if (!trimmed.startsWith("origin/")) {
+                return undefined;
+            }
+            const branch = trimmed.slice("origin/".length);
+            return branch ? `refs/heads/${branch}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    runGitRemoteCommand(installedPath, args) {
+        return this.runCommandCapture("git", args, {
+            cwd: installedPath,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+            env: {
+                GIT_TERMINAL_PROMPT: "0",
+            },
+        });
+    }
+    async runWithConcurrency(tasks, limit) {
+        if (tasks.length === 0) {
+            return [];
+        }
+        const results = new Array(tasks.length);
+        let nextIndex = 0;
+        const workerCount = Math.max(1, Math.min(limit, tasks.length));
+        const worker = async () => {
+            while (true) {
+                const index = nextIndex;
+                nextIndex += 1;
+                if (index >= tasks.length) {
+                    return;
+                }
+                results[index] = await tasks[index]();
+            }
+        };
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        return results;
+    }
     /**
      * Get a unique identity for a package, ignoring version/ref.
      * Used to detect when the same package is in both global and project settings.
@@ -1447,6 +1583,49 @@ export class DefaultPackageManager {
             themes: toResolved(accumulator.themes),
         };
     }
+    runCommandCapture(command, args, options) {
+        return new Promise((resolvePromise, reject) => {
+            const child = spawn(command, args, {
+                cwd: options?.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: process.platform === "win32",
+                env: options?.env ? { ...process.env, ...options.env } : process.env,
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = typeof options?.timeoutMs === "number"
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, options.timeoutMs)
+                : undefined;
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            child.on("error", (error) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(error);
+            });
+            child.on("exit", (code) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                if (timedOut) {
+                    reject(new Error(`${command} ${args.join(" ")} timed out after ${options?.timeoutMs}ms`));
+                    return;
+                }
+                if (code === 0) {
+                    resolvePromise(stdout.trim());
+                    return;
+                }
+                reject(new Error(`${command} ${args.join(" ")} failed with code ${code}: ${stderr || stdout}`));
+            });
+        });
+    }
     runCommand(command, args, options) {
         return new Promise((resolvePromise, reject) => {
             const child = spawn(command, args, {