@astralyn/pi 1.4.10 → 1.5.0

package/dist/core/resource-loader.js

@@ -1,21 +1,20 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, resolve, sep } from "node:path";
 import { detectCapabilities, getTerminalColorMode } from "@earendil-works/pi-tui";
 import chalk from "chalk";
-import { CONFIG_DIR_NAME } from "../config.js";
+import { APP_NAME, CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
-import { isPathInside, samePath } from "../utils/path-identity.js";
-import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, isPathWithin, pathsEqual, resolvePath } from "../utils/paths.js";
 import { stripBom } from "../utils/text.js";
 import { createEventBus } from "./event-bus.js";
 import { clearExtensionCache, createExtensionRuntime, loadExtensionFromFactory, loadExtensionsCached, } from "./extensions/loader.js";
 import { findGitPaths } from "./footer-data-provider.js";
-import { DefaultPackageManager } from "./package-manager.js";
+import { DefaultPackageManager, } from "./package-manager.js";
 import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { SkillInvocationPolicy } from "./skill-invocation.js";
 import { loadSkills } from "./skills.js";
-import { BUILTIN_PATH_PREFIX, createSourceInfo, getSyntheticPathSource, isSyntheticPath, } from "./source-info.js";
+import { BUILTIN_PATH_PREFIX, createSourceInfo, getResourcePathKey, getSyntheticPathSource, isSyntheticPath, } from "./source-info.js";
 import { resetTimings } from "./timings.js";
 const HOST_PROVIDED_EXTENSION_PACKAGES = new Set([
     "@earendil-works/pi-agent-core",
@@ -56,6 +55,20 @@ function collectExtensionPackageWarnings(extensionPaths, metadataByPath) {
     }
     return warnings;
 }
+/** Describe a package that was skipped because it could not be installed, including how to drop it. */
+function describePackageInstallFailure(failure) {
+    const hint = failure.scope === "temporary"
+        ? "Check the source and try again."
+        : `Run "${APP_NAME} remove ${failure.source}${failure.scope === "project" ? " --local" : ""}" to remove it from settings.json.`;
+    return `failed to install (${failure.message}). ${hint}`;
+}
+/** One-line startup warning for a package that could not be installed. */
+export function formatPackageInstallWarning(failure) {
+    return `Extension package "${failure.source}": ${describePackageInstallFailure(failure)}`;
+}
+function collectPackageInstallWarnings(...failures) {
+    return failures.flatMap((entries) => (entries ?? []).map((failure) => ({ path: failure.source, warning: describePackageInstallFailure(failure) })));
+}
 function mergeExtensionWarnings(result, warnings) {
     result.warnings = [
         ...new Map([...(result.warnings ?? []), ...warnings].map((warning) => [warning.path, warning])).values(),
@@ -153,13 +166,13 @@ function findShadowedContextFile(cwd) {
     const mainRepoRoot = dirname(commonGitDir);
     // False for an ordinary repo, where the two are the same dir, and for a sibling
     // worktree (`git worktree add ../feat`), whose main repo is not an ancestor.
-    if (!isPathInside(mainRepoRoot, worktreeRoot))
+    if (!isPathWithin(mainRepoRoot, worktreeRoot) || pathsEqual(worktreeRoot, mainRepoRoot))
         return undefined;
     // dirname of the common git dir is the main worktree root only when that dir is
     // itself checked out from the same repo. In a bare layout (`proj/.bare` +
     // `proj/main`) it is just the directory holding `.bare`, which tracks nothing; a
     // submodule's gitdir has no `commondir`, so it lands under `.git/modules`.
-    if (!samePath(join(mainRepoRoot, ".git"), commonGitDir))
+    if (!pathsEqual(canonicalizePath(join(mainRepoRoot, ".git")), commonGitDir))
         return undefined;
     const worktreeContextFile = loadContextFileFromDir(worktreeRoot);
     return worktreeContextFile ? join(mainRepoRoot, basename(worktreeContextFile.path)) : undefined;
@@ -180,11 +193,10 @@ export function loadProjectContextFiles(options) {
     while (true) {
         const contextFile = loadContextFileFromDir(currentDir);
         // Compare the directory's real path, not the file's: a worktree AGENTS.md that
-        // symlinks to the main repo's file resolves to the shadowed path itself. relative()
-        // keeps the comparison Windows drive-letter-case-insensitive.
+        // symlinks to the main repo's file resolves to the shadowed path itself.
         const isShadowed = shadowedContextFile !== undefined &&
             contextFile !== null &&
-            relative(join(canonicalizePath(currentDir), basename(contextFile.path)), shadowedContextFile) === "";
+            pathsEqual(join(canonicalizePath(currentDir), basename(contextFile.path)), shadowedContextFile);
         if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
             ancestorContextFiles.unshift(contextFile);
             seenPaths.add(contextFile.path);
@@ -328,6 +340,7 @@ export class DefaultResourceLoader {
         const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
             temporary: true,
         });
+        const installWarnings = collectPackageInstallWarnings(resolvedPaths.installFailures, cliExtensionPaths.installFailures);
         // Kept on the instance so post-reload passes (extendResources) can still resolve package metadata.
         this.resourceMetadataByPath = new Map();
         const metadataByPath = this.resourceMetadataByPath;
@@ -368,7 +381,7 @@ export class DefaultResourceLoader {
             !this.disabledBuiltinExtensions.has(path.slice(BUILTIN_PATH_PREFIX.length)));
         const packageWarnings = collectExtensionPackageWarnings(extensionPaths, metadataByPath);
         const extensionsResult = await this.loadFinalExtensionSet(extensionPaths, preTrustExtensions);
-        mergeExtensionWarnings(extensionsResult, packageWarnings);
+        mergeExtensionWarnings(extensionsResult, [...installWarnings, ...packageWarnings]);
         for (const p of this.additionalExtensionPaths) {
             if (isLocalPath(p)) {
                 const resolved = this.resolveResourcePath(p);
@@ -466,8 +479,9 @@ export class DefaultResourceLoader {
             resource.metadata,
         ]));
         const packageWarnings = collectExtensionPackageWarnings(extensionPaths, metadataByPath);
+        const installWarnings = collectPackageInstallWarnings(resolvedPaths.installFailures, cliExtensionPaths.installFailures);
         const extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
-        mergeExtensionWarnings(extensionsResult, packageWarnings);
+        mergeExtensionWarnings(extensionsResult, [...installWarnings, ...packageWarnings]);
         if (!options.includeInlineFactories) {
             return extensionsResult;
         }
@@ -482,6 +496,9 @@ export class DefaultResourceLoader {
     resolveExtensionLoadPath(path) {
         return isSyntheticPath(path) ? path : resolvePath(path, this.cwd, { normalizeUnicodeSpaces: true });
     }
+    getExtensionPathKey(path) {
+        return getResourcePathKey(this.resolveExtensionLoadPath(path));
+    }
     /** Load extension paths: files from disk and `builtin:<name>` paths from the built-in extensions. */
     async loadExtensionPaths(paths, runtime) {
         const isBuiltinPath = (path) => path.startsWith(BUILTIN_PATH_PREFIX);
@@ -509,22 +526,22 @@ export class DefaultResourceLoader {
         const preloaded = preTrustExtensions?.extensions ?? [];
         const preloadedByPath = new Map(preloaded
             .filter((extension) => !extension.path.startsWith("<inline:"))
-            .map((extension) => [extension.resolvedPath, extension]));
-        const failedPreloadPaths = new Set((preTrustExtensions?.errors ?? []).map((error) => this.resolveExtensionLoadPath(error.path)));
+            .map((extension) => [getResourcePathKey(extension.resolvedPath), extension]));
+        const failedPreloadPaths = new Set((preTrustExtensions?.errors ?? []).map((error) => this.getExtensionPathKey(error.path)));
         const remainingPaths = extensionPaths.filter((path) => {
-            const resolvedPath = this.resolveExtensionLoadPath(path);
-            return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
+            const pathKey = this.getExtensionPathKey(path);
+            return !preloadedByPath.has(pathKey) && !failedPreloadPaths.has(pathKey);
         });
         const remainingExtensions = await this.loadExtensionPaths(remainingPaths, preTrustExtensions?.runtime);
         const loadedByPath = new Map(preloadedByPath);
         for (const extension of remainingExtensions.extensions) {
-            loadedByPath.set(extension.resolvedPath, extension);
+            loadedByPath.set(getResourcePathKey(extension.resolvedPath), extension);
         }
         const inlineExtensions = preTrustExtensions
             ? { extensions: preloaded.filter((extension) => extension.path.startsWith("<inline:")), errors: [] }
             : await this.loadExtensionFactories(remainingExtensions.runtime);
         const orderedExtensions = extensionPaths
-            .map((path) => loadedByPath.get(this.resolveExtensionLoadPath(path)))
+            .map((path) => loadedByPath.get(this.getExtensionPathKey(path)))
             .filter((extension) => extension !== undefined);
         orderedExtensions.push(...inlineExtensions.extensions);
         const replacementWarnings = [];
@@ -689,9 +706,7 @@ export class DefaultResourceLoader {
         const normalizedResourcePath = resolve(resourcePath);
         if (extraSourceInfos) {
             for (const [sourcePath, sourceInfo] of extraSourceInfos.entries()) {
-                const normalizedSourcePath = resolve(sourcePath);
-                if (normalizedResourcePath === normalizedSourcePath ||
-                    normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                if (isPathWithin(sourcePath, normalizedResourcePath)) {
                     return { ...sourceInfo, path: resourcePath };
                 }
             }
@@ -702,9 +717,7 @@ export class DefaultResourceLoader {
                 return createSourceInfo(resourcePath, exact);
             }
             for (const [sourcePath, metadata] of metadataByPath.entries()) {
-                const normalizedSourcePath = resolve(sourcePath);
-                if (normalizedResourcePath === normalizedSourcePath ||
-                    normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                if (isPathWithin(sourcePath, normalizedResourcePath)) {
                     return createSourceInfo(resourcePath, metadata);
                 }
             }
@@ -757,10 +770,10 @@ export class DefaultResourceLoader {
         const seen = new Set();
         for (const p of [...primary, ...additional]) {
             const resolved = this.resolveResourcePath(p);
-            const canonicalPath = canonicalizePath(resolved);
-            if (seen.has(canonicalPath))
+            const pathKey = getResourcePathKey(resolved);
+            if (seen.has(pathKey))
                 continue;
-            seen.add(canonicalPath);
+            seen.add(pathKey);
             merged.push(resolved);
         }
         return merged;