@earendil-works/pi-coding-agent 0.75.4 → 0.76.0

package/dist/core/package-manager.js

@@ -27,7 +27,7 @@ import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { spawnProcess, spawnProcessSync } from "../utils/child-process.js";
 import { parseGitUrl } from "../utils/git.js";
-import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync, resolvePath } from "../utils/paths.js";
 import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
 const UPDATE_CHECK_CONCURRENCY = 4;
@@ -577,8 +577,8 @@ export class DefaultPackageManager {
     globalNpmRootCommandKey;
     progressCallback;
     constructor(options) {
-        this.cwd = options.cwd;
-        this.agentDir = options.agentDir;
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
         this.settingsManager = options.settingsManager;
     }
     setProgressCallback(callback) {
@@ -589,9 +589,22 @@ export class DefaultPackageManager {
         const currentSettings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings();
         const currentPackages = currentSettings.packages ?? [];
         const normalizedSource = this.normalizePackageSourceForSettings(source, scope);
-        const exists = currentPackages.some((existing) => this.packageSourcesMatch(existing, source, scope));
-        if (exists) {
-            return false;
+        const matchIndex = currentPackages.findIndex((existing) => this.packageSourcesMatch(existing, source, scope));
+        if (matchIndex !== -1) {
+            const existing = currentPackages[matchIndex];
+            if (this.getPackageSourceString(existing) === normalizedSource) {
+                return false;
+            }
+            const nextPackages = [...currentPackages];
+            nextPackages[matchIndex] =
+                typeof existing === "string" ? normalizedSource : { ...existing, source: normalizedSource };
+            if (scope === "project") {
+                this.settingsManager.setProjectPackages(nextPackages);
+            }
+            else {
+                this.settingsManager.setPackages(nextPackages);
+            }
+            return true;
         }
         const nextPackages = [...currentPackages, normalizedSource];
         if (scope === "project") {
@@ -801,14 +814,16 @@ export class DefaultPackageManager {
         const gitCandidates = [];
         for (const entry of sources) {
             const parsed = this.parseSource(entry.source);
-            if (parsed.type === "local" || parsed.pinned) {
-                continue;
-            }
+            // Pinned npm versions are fixed. Pinned git refs are configured checkout targets,
+            // so include them to reconcile an existing clone when the configured ref changes.
             if (parsed.type === "npm") {
-                npmCandidates.push({ ...entry, parsed });
-                continue;
+                if (!parsed.pinned) {
+                    npmCandidates.push({ ...entry, parsed });
+                }
+            }
+            else if (parsed.type === "git") {
+                gitCandidates.push({ ...entry, parsed });
             }
-            gitCandidates.push({ ...entry, parsed });
         }
         const npmCheckTasks = npmCandidates.map((entry) => async () => ({
             entry,
@@ -1383,13 +1398,25 @@ export class DefaultPackageManager {
     }
     getNpmInstallArgs(specs, installRoot) {
         const packageManagerName = this.getPackageManagerName();
+        // Extension packages run inside pi and resolve pi APIs through loader aliases/virtual modules.
+        // Disable peer dependency resolution for managed installs (npm's --legacy-peer-deps, and
+        // equivalent bun/pnpm settings) so package managers do not install or solve host-provided
+        // @earendil-works/pi-* peers. Stale auto-installed pi peers can otherwise block updates.
         if (packageManagerName === "bun") {
-            return ["install", ...specs, "--cwd", installRoot];
+            return ["install", ...specs, "--cwd", installRoot, "--omit=peer"];
         }
         if (packageManagerName === "pnpm") {
-            return ["install", ...specs, "--prefix", installRoot, "--config.strict-dep-builds=false"];
-        }
-        return ["install", ...specs, "--prefix", installRoot];
+            return [
+                "install",
+                ...specs,
+                "--prefix",
+                installRoot,
+                "--config.auto-install-peers=false",
+                "--config.strict-peer-dependencies=false",
+                "--config.strict-dep-builds=false",
+            ];
+        }
+        return ["install", ...specs, "--prefix", installRoot, "--legacy-peer-deps"];
     }
     async installNpm(source, scope, temporary) {
         const installRoot = this.getNpmInstallRoot(scope, temporary);
@@ -1410,6 +1437,12 @@ export class DefaultPackageManager {
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
         if (existsSync(targetDir)) {
+            if (source.ref) {
+                await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
+                return;
+            }
+            const target = await this.getLocalGitUpdateTarget(targetDir);
+            await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
             return;
         }
         const gitRoot = this.getGitInstallRoot(scope);
@@ -1432,21 +1465,29 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
+        if (source.ref) {
+            await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
+            return;
+        }
         const target = await this.getLocalGitUpdateTarget(targetDir);
+        await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
+    }
+    async ensureGitRef(targetDir, fetchArgs, ref) {
         // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
-        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
+        await this.runCommand("git", fetchArgs, { cwd: targetDir });
         const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+        const commitRef = `${ref}^{commit}`;
+        const targetHead = await this.runCommandCapture("git", ["rev-parse", commitRef], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        if (localHead.trim() === refreshedTargetHead.trim()) {
+        if (localHead.trim() === targetHead.trim()) {
             return;
         }
-        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
+        await this.runCommand("git", ["reset", "--hard", commitRef], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
@@ -1616,24 +1657,10 @@ export class DefaultPackageManager {
         return this.cwd;
     }
     resolvePath(input) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(this.cwd, trimmed);
+        return resolvePath(input, this.cwd, { homeDir: getHomeDir(), trim: true });
     }
     resolvePathFromBase(input, baseDir) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(baseDir, trimmed);
+        return resolvePath(input, baseDir, { homeDir: getHomeDir(), trim: true });
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
         if (filter) {