@codex-infinity/pi-infinity 0.61.3 → 0.62.1

package/dist/core/resource-loader.js

@@ -10,6 +10,7 @@ import { DefaultPackageManager } from "./package-manager.js";
 import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills } from "./skills.js";
+import { createSourceInfo } from "./source-info.js";
 function resolvePromptInput(input, description) {
     if (!input) {
         return undefined;
@@ -110,8 +111,10 @@ export class DefaultResourceLoader {
         this.themeDiagnostics = [];
         this.agentsFiles = [];
         this.appendSystemPrompt = [];
-        this.pathMetadata = new Map();
         this.lastSkillPaths = [];
+        this.extensionSkillSourceInfos = new Map();
+        this.extensionPromptSourceInfos = new Map();
+        this.extensionThemeSourceInfos = new Map();
         this.lastPromptPaths = [];
         this.lastThemePaths = [];
     }
@@ -136,24 +139,30 @@ export class DefaultResourceLoader {
     getAppendSystemPrompt() {
         return this.appendSystemPrompt;
     }
-    getPathMetadata() {
-        return this.pathMetadata;
-    }
     extendResources(paths) {
         const skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []);
         const promptPaths = this.normalizeExtensionPaths(paths.promptPaths ?? []);
         const themePaths = this.normalizeExtensionPaths(paths.themePaths ?? []);
+        for (const entry of skillPaths) {
+            this.extensionSkillSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        for (const entry of promptPaths) {
+            this.extensionPromptSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        for (const entry of themePaths) {
+            this.extensionThemeSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
         if (skillPaths.length > 0) {
             this.lastSkillPaths = this.mergePaths(this.lastSkillPaths, skillPaths.map((entry) => entry.path));
-            this.updateSkillsFromPaths(this.lastSkillPaths, skillPaths);
+            this.updateSkillsFromPaths(this.lastSkillPaths);
         }
         if (promptPaths.length > 0) {
             this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path));
-            this.updatePromptsFromPaths(this.lastPromptPaths, promptPaths);
+            this.updatePromptsFromPaths(this.lastPromptPaths);
         }
         if (themePaths.length > 0) {
             this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path));
-            this.updateThemesFromPaths(this.lastThemePaths, themePaths);
+            this.updateThemesFromPaths(this.lastThemePaths);
         }
     }
     async reload() {
@@ -161,18 +170,20 @@ export class DefaultResourceLoader {
         const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
             temporary: true,
         });
+        const metadataByPath = new Map();
+        this.extensionSkillSourceInfos = new Map();
+        this.extensionPromptSourceInfos = new Map();
+        this.extensionThemeSourceInfos = new Map();
         // Helper to extract enabled paths and store metadata
         const getEnabledResources = (resources) => {
             for (const r of resources) {
-                if (!this.pathMetadata.has(r.path)) {
-                    this.pathMetadata.set(r.path, r.metadata);
+                if (!metadataByPath.has(r.path)) {
+                    metadataByPath.set(r.path, r.metadata);
                 }
             }
             return resources.filter((r) => r.enabled);
         };
         const getEnabledPaths = (resources) => getEnabledResources(resources).map((r) => r.path);
-        // Store metadata and get enabled paths
-        this.pathMetadata = new Map();
         const enabledExtensions = getEnabledPaths(resolvedPaths.extensions);
         const enabledSkillResources = getEnabledResources(resolvedPaths.skills);
         const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
@@ -192,8 +203,8 @@ export class DefaultResourceLoader {
             }
             const skillFile = join(resource.path, "SKILL.md");
             if (existsSync(skillFile)) {
-                if (!this.pathMetadata.has(skillFile)) {
-                    this.pathMetadata.set(skillFile, resource.metadata);
+                if (!metadataByPath.has(skillFile)) {
+                    metadataByPath.set(skillFile, resource.metadata);
                 }
                 return skillFile;
             }
@@ -202,13 +213,13 @@ export class DefaultResourceLoader {
         const enabledSkills = enabledSkillResources.map(mapSkillPath);
         // Add CLI paths metadata
         for (const r of cliExtensionPaths.extensions) {
-            if (!this.pathMetadata.has(r.path)) {
-                this.pathMetadata.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
+            if (!metadataByPath.has(r.path)) {
+                metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
             }
         }
         for (const r of cliExtensionPaths.skills) {
-            if (!this.pathMetadata.has(r.path)) {
-                this.pathMetadata.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
+            if (!metadataByPath.has(r.path)) {
+                metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
             }
         }
         const cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions);
@@ -229,24 +240,22 @@ export class DefaultResourceLoader {
             extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
         }
         this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
+        this.applyExtensionSourceInfo(this.extensionsResult.extensions, metadataByPath);
         const skillPaths = this.noSkills
             ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths)
             : this.mergePaths([...enabledSkills, ...cliEnabledSkills], this.additionalSkillPaths);
         this.lastSkillPaths = skillPaths;
-        this.updateSkillsFromPaths(skillPaths);
+        this.updateSkillsFromPaths(skillPaths, metadataByPath);
         const promptPaths = this.noPromptTemplates
             ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths)
             : this.mergePaths([...enabledPrompts, ...cliEnabledPrompts], this.additionalPromptTemplatePaths);
         this.lastPromptPaths = promptPaths;
-        this.updatePromptsFromPaths(promptPaths);
+        this.updatePromptsFromPaths(promptPaths, metadataByPath);
         const themePaths = this.noThemes
             ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths)
             : this.mergePaths([...enabledThemes, ...cliEnabledThemes], this.additionalThemePaths);
         this.lastThemePaths = themePaths;
-        this.updateThemesFromPaths(themePaths);
-        for (const extension of this.extensionsResult.extensions) {
-            this.addDefaultMetadataForPath(extension.path);
-        }
+        this.updateThemesFromPaths(themePaths, metadataByPath);
         const agentsFiles = { agentsFiles: loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }) };
         const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
         this.agentsFiles = resolvedAgentsFiles.agentsFiles;
@@ -265,7 +274,7 @@ export class DefaultResourceLoader {
             metadata: entry.metadata,
         }));
     }
-    updateSkillsFromPaths(skillPaths, extensionPaths = []) {
+    updateSkillsFromPaths(skillPaths, metadataByPath) {
         let skillsResult;
         if (this.noSkills && skillPaths.length === 0) {
             skillsResult = { skills: [], diagnostics: [] };
@@ -279,14 +288,15 @@ export class DefaultResourceLoader {
             });
         }
         const resolvedSkills = this.skillsOverride ? this.skillsOverride(skillsResult) : skillsResult;
-        this.skills = resolvedSkills.skills;
+        this.skills = resolvedSkills.skills.map((skill) => ({
+            ...skill,
+            sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ??
+                skill.sourceInfo ??
+                this.getDefaultSourceInfoForPath(skill.filePath),
+        }));
         this.skillDiagnostics = resolvedSkills.diagnostics;
-        this.applyExtensionMetadata(extensionPaths, this.skills.map((skill) => skill.filePath));
-        for (const skill of this.skills) {
-            this.addDefaultMetadataForPath(skill.filePath);
-        }
     }
-    updatePromptsFromPaths(promptPaths, extensionPaths = []) {
+    updatePromptsFromPaths(promptPaths, metadataByPath) {
         let promptsResult;
         if (this.noPromptTemplates && promptPaths.length === 0) {
             promptsResult = { prompts: [], diagnostics: [] };
@@ -301,14 +311,15 @@ export class DefaultResourceLoader {
             promptsResult = this.dedupePrompts(allPrompts);
         }
         const resolvedPrompts = this.promptsOverride ? this.promptsOverride(promptsResult) : promptsResult;
-        this.prompts = resolvedPrompts.prompts;
+        this.prompts = resolvedPrompts.prompts.map((prompt) => ({
+            ...prompt,
+            sourceInfo: this.findSourceInfoForPath(prompt.filePath, this.extensionPromptSourceInfos, metadataByPath) ??
+                prompt.sourceInfo ??
+                this.getDefaultSourceInfoForPath(prompt.filePath),
+        }));
         this.promptDiagnostics = resolvedPrompts.diagnostics;
-        this.applyExtensionMetadata(extensionPaths, this.prompts.map((prompt) => prompt.filePath));
-        for (const prompt of this.prompts) {
-            this.addDefaultMetadataForPath(prompt.filePath);
-        }
     }
-    updateThemesFromPaths(themePaths, extensionPaths = []) {
+    updateThemesFromPaths(themePaths, metadataByPath) {
         let themesResult;
         if (this.noThemes && themePaths.length === 0) {
             themesResult = { themes: [], diagnostics: [] };
@@ -319,39 +330,101 @@ export class DefaultResourceLoader {
             themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
         }
         const resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
-        this.themes = resolvedThemes.themes;
+        this.themes = resolvedThemes.themes.map((theme) => {
+            const sourcePath = theme.sourcePath;
+            theme.sourceInfo = sourcePath
+                ? (this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ??
+                    theme.sourceInfo ??
+                    this.getDefaultSourceInfoForPath(sourcePath))
+                : theme.sourceInfo;
+            return theme;
+        });
         this.themeDiagnostics = resolvedThemes.diagnostics;
-        const themePathsWithSource = this.themes.flatMap((theme) => (theme.sourcePath ? [theme.sourcePath] : []));
-        this.applyExtensionMetadata(extensionPaths, themePathsWithSource);
-        for (const theme of this.themes) {
-            if (theme.sourcePath) {
-                this.addDefaultMetadataForPath(theme.sourcePath);
+    }
+    applyExtensionSourceInfo(extensions, metadataByPath) {
+        for (const extension of extensions) {
+            extension.sourceInfo =
+                this.findSourceInfoForPath(extension.path, undefined, metadataByPath) ??
+                    this.getDefaultSourceInfoForPath(extension.path);
+            for (const command of extension.commands.values()) {
+                command.sourceInfo = extension.sourceInfo;
+            }
+            for (const tool of extension.tools.values()) {
+                tool.sourceInfo = extension.sourceInfo;
             }
         }
     }
-    applyExtensionMetadata(extensionPaths, resourcePaths) {
-        if (extensionPaths.length === 0) {
-            return;
+    findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {
+        if (!resourcePath) {
+            return undefined;
         }
-        const normalized = extensionPaths.map((entry) => ({
-            path: resolve(entry.path),
-            metadata: entry.metadata,
-        }));
-        for (const entry of normalized) {
-            if (!this.pathMetadata.has(entry.path)) {
-                this.pathMetadata.set(entry.path, entry.metadata);
+        if (resourcePath.startsWith("<")) {
+            return this.getDefaultSourceInfoForPath(resourcePath);
+        }
+        const normalizedResourcePath = resolve(resourcePath);
+        if (extraSourceInfos) {
+            for (const [sourcePath, sourceInfo] of extraSourceInfos.entries()) {
+                const normalizedSourcePath = resolve(sourcePath);
+                if (normalizedResourcePath === normalizedSourcePath ||
+                    normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                    return { ...sourceInfo, path: resourcePath };
+                }
             }
         }
-        for (const resourcePath of resourcePaths) {
-            const normalizedResourcePath = resolve(resourcePath);
-            if (this.pathMetadata.has(normalizedResourcePath) || this.pathMetadata.has(resourcePath)) {
-                continue;
+        if (metadataByPath) {
+            const exact = metadataByPath.get(normalizedResourcePath) ?? metadataByPath.get(resourcePath);
+            if (exact) {
+                return createSourceInfo(resourcePath, exact);
+            }
+            for (const [sourcePath, metadata] of metadataByPath.entries()) {
+                const normalizedSourcePath = resolve(sourcePath);
+                if (normalizedResourcePath === normalizedSourcePath ||
+                    normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                    return createSourceInfo(resourcePath, metadata);
+                }
+            }
+        }
+        return undefined;
+    }
+    getDefaultSourceInfoForPath(filePath) {
+        if (filePath.startsWith("<") && filePath.endsWith(">")) {
+            return {
+                path: filePath,
+                source: filePath.slice(1, -1).split(":")[0] || "temporary",
+                scope: "temporary",
+                origin: "top-level",
+            };
+        }
+        const normalizedPath = resolve(filePath);
+        const agentRoots = [
+            join(this.agentDir, "skills"),
+            join(this.agentDir, "prompts"),
+            join(this.agentDir, "themes"),
+            join(this.agentDir, "extensions"),
+        ];
+        const projectRoots = [
+            join(this.cwd, CONFIG_DIR_NAME, "skills"),
+            join(this.cwd, CONFIG_DIR_NAME, "prompts"),
+            join(this.cwd, CONFIG_DIR_NAME, "themes"),
+            join(this.cwd, CONFIG_DIR_NAME, "extensions"),
+        ];
+        for (const root of agentRoots) {
+            if (this.isUnderPath(normalizedPath, root)) {
+                return { path: filePath, source: "local", scope: "user", origin: "top-level", baseDir: root };
             }
-            const match = normalized.find((entry) => normalizedResourcePath === entry.path || normalizedResourcePath.startsWith(`${entry.path}${sep}`));
-            if (match) {
-                this.pathMetadata.set(normalizedResourcePath, match.metadata);
+        }
+        for (const root of projectRoots) {
+            if (this.isUnderPath(normalizedPath, root)) {
+                return { path: filePath, source: "local", scope: "project", origin: "top-level", baseDir: root };
             }
         }
+        return {
+            path: filePath,
+            source: "local",
+            scope: "temporary",
+            origin: "top-level",
+            baseDir: statSync(normalizedPath).isDirectory() ? normalizedPath : resolve(normalizedPath, ".."),
+        };
     }
     mergePaths(primary, additional) {
         const merged = [];
@@ -539,39 +612,6 @@ export class DefaultResourceLoader {
         }
         return undefined;
     }
-    addDefaultMetadataForPath(filePath) {
-        if (!filePath || filePath.startsWith("<")) {
-            return;
-        }
-        const normalizedPath = resolve(filePath);
-        if (this.pathMetadata.has(normalizedPath) || this.pathMetadata.has(filePath)) {
-            return;
-        }
-        const agentRoots = [
-            join(this.agentDir, "skills"),
-            join(this.agentDir, "prompts"),
-            join(this.agentDir, "themes"),
-            join(this.agentDir, "extensions"),
-        ];
-        const projectRoots = [
-            join(this.cwd, CONFIG_DIR_NAME, "skills"),
-            join(this.cwd, CONFIG_DIR_NAME, "prompts"),
-            join(this.cwd, CONFIG_DIR_NAME, "themes"),
-            join(this.cwd, CONFIG_DIR_NAME, "extensions"),
-        ];
-        for (const root of agentRoots) {
-            if (this.isUnderPath(normalizedPath, root)) {
-                this.pathMetadata.set(normalizedPath, { source: "local", scope: "user", origin: "top-level" });
-                return;
-            }
-        }
-        for (const root of projectRoots) {
-            if (this.isUnderPath(normalizedPath, root)) {
-                this.pathMetadata.set(normalizedPath, { source: "local", scope: "project", origin: "top-level" });
-                return;
-            }
-        }
-    }
     isUnderPath(target, root) {
         const normalizedRoot = resolve(root);
         if (target === normalizedRoot) {
@@ -582,9 +622,8 @@ export class DefaultResourceLoader {
     }
     detectExtensionConflicts(extensions) {
         const conflicts = [];
-        // Track which extension registered each tool, command, and flag
+        // Track which extension registered each tool and flag
         const toolOwners = new Map();
-        const commandOwners = new Map();
         const flagOwners = new Map();
         for (const ext of extensions) {
             // Check tools
@@ -600,19 +639,6 @@ export class DefaultResourceLoader {
                     toolOwners.set(toolName, ext.path);
                 }
             }
-            // Check commands
-            for (const commandName of ext.commands.keys()) {
-                const existingOwner = commandOwners.get(commandName);
-                if (existingOwner && existingOwner !== ext.path) {
-                    conflicts.push({
-                        path: ext.path,
-                        message: `Command "/${commandName}" conflicts with ${existingOwner}`,
-                    });
-                }
-                else {
-                    commandOwners.set(commandName, ext.path);
-                }
-            }
             // Check flags
             for (const flagName of ext.flags.keys()) {
                 const existingOwner = flagOwners.get(flagName);