@selesai/code 0.2.1 → 0.3.1

package/dist/core/package-manager.js

@@ -20,12 +20,12 @@ function getEnv() {
         return process.env;
     }
 }
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { globSync } from "glob";
 import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { maxSatisfying, rcompare, satisfies, valid, validRange } from "semver";
-import { CONFIG_DIR_NAME } from "../config.js";
+import { CONFIG_DIR_NAME, getBundledExtensionsDir } from "../config.js";
 import { spawnProcess, spawnProcessSync } from "../utils/child-process.js";
 import { parseGitUrl } from "../utils/git.js";
 import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync, resolvePath } from "../utils/paths.js";
@@ -398,6 +398,22 @@ function resolveExtensionEntries(dir) {
     }
     return null;
 }
+/**
+ * Derive the top-level extension entry name for a resolved extension path,
+ * relative to its extensions root dir. Loose files map to their extension id
+ * without script suffix (e.g. "copy-turn.ts" -> "copy-turn"); package/dir extensions map to their containing
+ * entry dir (e.g. "pi-subagents"). Returns undefined if the path is not
+ * under the given root (e.g. a settings-listed absolute path elsewhere).
+ */
+export function extensionEntryName(extPath, extensionsRoot) {
+    const rel = relative(resolve(extensionsRoot), resolve(extPath));
+    if (rel.startsWith("..") || isAbsolute(rel))
+        return undefined;
+    const first = rel.split(sep)[0];
+    if (!first)
+        return undefined;
+    return first.endsWith(".ts") || first.endsWith(".js") ? first.slice(0, -3) : first;
+}
 function collectAutoExtensionEntries(dir) {
     const entries = [];
     if (!existsSync(dir))
@@ -710,15 +726,15 @@ export class DefaultPackageManager {
                 origin: "top-level",
             }, globalBaseDir);
         }
-        this.addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir);
-        return this.toResolvedPaths(accumulator);
+        const collisions = this.addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir);
+        return this.toResolvedPaths(accumulator, collisions);
     }
     async resolveExtensionSources(sources, options) {
         const accumulator = this.createAccumulator();
         const scope = options?.temporary ? "temporary" : options?.local ? "project" : "user";
         const packageSources = sources.map((source) => ({ pkg: source, scope }));
         await this.resolvePackageSources(packageSources, accumulator);
-        return this.toResolvedPaths(accumulator);
+        return this.toResolvedPaths(accumulator, []);
     }
     listConfiguredPackages() {
         const globalSettings = this.settingsManager.getGlobalSettings();
@@ -1850,6 +1866,7 @@ export class DefaultPackageManager {
         }
     }
     addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir) {
+        const collisions = [];
         const userMetadata = {
             source: "auto",
             scope: "user",
@@ -1917,9 +1934,75 @@ export class DefaultPackageManager {
             addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
             addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
         }
-        // User extensions from ~/.pi/agent/
+        // User extensions from ~/.selesai/agent/
         addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
-        // User skills from ~/.pi/agent/
+        // ponytail: also load user extensions from the host pi dir (~/.pi/agent/extensions)
+        // so selesai reuses pi-installed extensions without sharing auth/models/sessions.
+        // Coupling: hardcodes ".pi" — if pi renames its config dir this silently stops loading.
+        // Upgrade path: read from a resolver if selesai ever needs to locate the host dynamically.
+        const piHostExtDir = join(getHomeDir(), ".pi", "agent", "extensions");
+        const piHostBaseDir = join(getHomeDir(), ".pi", "agent");
+        const selesaiExtSource = "~/.selesai/agent/extensions";
+        const piExtSource = "~/.pi/agent/extensions";
+        // On name collisions between ~/.selesai/agent/extensions and ~/.pi/agent/extensions,
+        // drop the loser entirely (avoids double-load split-brain in stateful extensions
+        // like pi-subagents) and record a collision so the user is told. Winner is settable
+        // per extension via `extensionHost` in settings.json; default is selesai.
+        const extensionHost = globalSettings.extensionHost ?? {};
+        const selesaiPathsByName = new Map();
+        for (const extPath of accumulator.extensions.keys()) {
+            const name = extensionEntryName(extPath, userDirs.extensions);
+            if (name)
+                selesaiPathsByName.set(name, extPath);
+        }
+        // ponytail: bundled built-in extensions (src/extensions, shipped with selesai)
+        // are the selesai side too: a pi-host copy of the same name must be dropped here
+        // or detectExtensionConflicts() throws a fatal tool conflict at load time
+        // (e.g. selesai's bundled question vs ~/.pi/agent/extensions/question.ts).
+        // Bundled always wins — extensionHost can't override it (it loads via
+        // additionalExtensionPaths at boot, not the accumulator, so delete() is a no-op
+        // and a pi-winner override would leave both loaded = fatal conflict).
+        const bundledExtDir = getBundledExtensionsDir();
+        const bundledExtNames = new Set();
+        for (const extPath of collectAutoExtensionEntries(bundledExtDir)) {
+            const name = extensionEntryName(extPath, bundledExtDir);
+            if (name) {
+                bundledExtNames.add(name);
+                if (!selesaiPathsByName.has(name))
+                    selesaiPathsByName.set(name, extPath);
+            }
+        }
+        const piHostEntries = collectAutoExtensionEntries(piHostExtDir);
+        const piHostKept = [];
+        for (const extPath of piHostEntries) {
+            const name = extensionEntryName(extPath, piHostExtDir);
+            if (!name || !selesaiPathsByName.has(name)) {
+                piHostKept.push(extPath);
+                continue;
+            }
+            // Collision: pick winner per settings; default selesai.
+            // Bundled always wins — ignore a "pi" override for bundled extensions.
+            const isBundled = bundledExtNames.has(name);
+            const winner = isBundled ? "selesai" : (extensionHost[name] ?? "selesai");
+            const selesaiWins = winner === "selesai";
+            const selesaiPath = selesaiPathsByName.get(name);
+            if (!selesaiWins) {
+                // Drop the selesai copy so pi's wins; register pi's path.
+                accumulator.extensions.delete(selesaiPath);
+                piHostKept.push(extPath);
+            }
+            collisions.push({
+                resourceType: "extension",
+                name,
+                winnerPath: selesaiWins ? selesaiPath : extPath,
+                loserPath: selesaiWins ? extPath : selesaiPath,
+                winnerSource: selesaiWins ? selesaiExtSource : piExtSource,
+                loserSource: selesaiWins ? piExtSource : selesaiExtSource,
+                winner,
+            });
+        }
+        addResources("extensions", piHostKept, { ...userMetadata, baseDir: piHostBaseDir }, userOverrides.extensions, piHostBaseDir);
+        // User skills from ~/.selesai/agent/
         addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir);
         // User skills from ~/.agents/ (with its own baseDir)
         const userAgentsBaseDir = dirname(userAgentsSkillsDir);
@@ -1930,6 +2013,7 @@ export class DefaultPackageManager {
         addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir);
         addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
+        return collisions;
     }
     collectFilesFromPaths(paths, resourceType) {
         const files = [];
@@ -1983,7 +2067,7 @@ export class DefaultPackageManager {
             agents: new Map(),
         };
     }
-    toResolvedPaths(accumulator) {
+    toResolvedPaths(accumulator, collisions) {
         const mapToResolved = (entries) => {
             const resolved = Array.from(entries.entries()).map(([path, { metadata, enabled }]) => ({
                 path,
@@ -2006,6 +2090,7 @@ export class DefaultPackageManager {
             prompts: mapToResolved(accumulator.prompts),
             themes: mapToResolved(accumulator.themes),
             agents: mapToResolved(accumulator.agents),
+            extensionCollisions: collisions,
         };
     }
     spawnCommand(command, args, options) {