@fleetagent/pi-coding-agent 0.0.10 → 0.0.12

package/dist/core/resource-loader.js

@@ -7,12 +7,12 @@ import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
 import { createEventBus } from "./event-bus.js";
 import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
 import { DefaultPackageManager } from "./package-manager.js";
-import { loadPromptTemplates } from "./prompt-templates.js";
-import { loadRules } from "./rules.js";
+import { loadPromptTemplates, loadPromptTemplatesWithOperations } from "./prompt-templates.js";
+import { loadRules, loadRulesWithOperations } from "./rules.js";
 import { SettingsManager } from "./settings-manager.js";
-import { loadSkills } from "./skills.js";
+import { loadSkills, loadSkillsWithOperations } from "./skills.js";
 import { createSourceInfo } from "./source-info.js";
-function resolvePromptInput(input, description) {
+async function resolvePromptInput(input, description, operations) {
     if (!input) {
         return undefined;
     }
@@ -25,6 +25,13 @@ function resolvePromptInput(input, description) {
             return input;
         }
     }
+    if (operations) {
+        try {
+            await operations.access(input, "read");
+            return (await operations.readFile(input)).toString("utf-8");
+        }
+        catch { }
+    }
     return input;
 }
 function loadContextFileFromDir(dir) {
@@ -74,6 +81,45 @@ export function loadProjectContextFiles(options) {
     contextFiles.push(...ancestorContextFiles);
     return contextFiles;
 }
+async function loadContextFileFromDirWithOperations(operations, dir) {
+    const candidates = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+    for (const filename of candidates) {
+        const filePath = join(dir, filename);
+        try {
+            await operations.access(filePath, "read");
+            return { path: filePath, content: (await operations.readFile(filePath)).toString("utf-8") };
+        }
+        catch { }
+    }
+    return null;
+}
+async function loadProjectContextFilesWithOperations(options) {
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvePath(options.agentDir));
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const ancestorContextFiles = [];
+    let currentDir = resolvePath(options.cwd);
+    const root = resolve("/");
+    while (true) {
+        const contextFile = await loadContextFileFromDirWithOperations(options.operations, currentDir);
+        if (contextFile && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        if (currentDir === root)
+            break;
+        const parentDir = resolve(currentDir, "..");
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    return contextFiles;
+}
 export class DefaultResourceLoader {
     cwd;
     agentDir;
@@ -94,6 +140,7 @@ export class DefaultResourceLoader {
     noContextFiles;
     systemPromptSource;
     appendSystemPromptSource;
+    toolOperations;
     extensionsOverride;
     skillsOverride;
     rulesOverride;
@@ -146,6 +193,7 @@ export class DefaultResourceLoader {
         this.noContextFiles = options.noContextFiles ?? false;
         this.systemPromptSource = options.systemPrompt;
         this.appendSystemPromptSource = options.appendSystemPrompt;
+        this.toolOperations = options.toolOperations;
         this.extensionsOverride = options.extensionsOverride;
         this.skillsOverride = options.skillsOverride;
         this.rulesOverride = options.rulesOverride;
@@ -198,6 +246,50 @@ export class DefaultResourceLoader {
     getAppendSystemPrompt() {
         return this.appendSystemPrompt;
     }
+    getInstructionOperations() {
+        const backend = this.toolOperations?.getBackendInfo?.();
+        return (backend?.type === "ssh" || backend?.type === "remote") && backend.configured
+            ? this.toolOperations
+            : undefined;
+    }
+    getRemoteProjectInstructionResourcePaths(cwd, source) {
+        const projectBaseDir = join(cwd, CONFIG_DIR_NAME);
+        const projectMetadata = {
+            source,
+            scope: "project",
+            origin: "top-level",
+            baseDir: projectBaseDir,
+        };
+        const skills = [
+            { path: join(projectBaseDir, "skills"), metadata: projectMetadata },
+        ];
+        const rules = [
+            { path: join(projectBaseDir, "rules"), metadata: projectMetadata },
+        ];
+        const prompts = [
+            { path: join(projectBaseDir, "prompts"), metadata: projectMetadata },
+        ];
+        let currentDir = resolve(cwd);
+        const root = resolve("/");
+        while (true) {
+            const agentsBaseDir = join(currentDir, ".agents");
+            const agentsMetadata = {
+                source,
+                scope: "project",
+                origin: "top-level",
+                baseDir: agentsBaseDir,
+            };
+            skills.push({ path: join(agentsBaseDir, "skills"), metadata: agentsMetadata });
+            rules.push({ path: join(agentsBaseDir, "rules"), metadata: agentsMetadata });
+            if (currentDir === root)
+                break;
+            const parentDir = resolve(currentDir, "..");
+            if (parentDir === currentDir)
+                break;
+            currentDir = parentDir;
+        }
+        return { skills, rules, prompts };
+    }
     extendResources(paths) {
         const skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []);
         const rulePaths = this.normalizeExtensionPaths(paths.rulePaths ?? []);
@@ -253,10 +345,16 @@ export class DefaultResourceLoader {
             return resources.filter((r) => r.enabled);
         };
         const getEnabledPaths = (resources) => getEnabledResources(resources).map((r) => r.path);
+        const instructionOperations = this.getInstructionOperations();
+        const loadProjectInstructionsRemotely = instructionOperations !== undefined;
+        const isLocalProjectInstructionResource = (resource) => loadProjectInstructionsRemotely &&
+            resource.metadata.scope === "project" &&
+            resource.metadata.origin === "top-level";
         const enabledExtensions = getEnabledPaths(resolvedPaths.extensions);
-        const enabledSkillResources = getEnabledResources(resolvedPaths.skills);
-        const enabledRuleResources = getEnabledResources(resolvedPaths.rules);
-        const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
+        const enabledSkillResources = getEnabledResources(resolvedPaths.skills).filter((resource) => !isLocalProjectInstructionResource(resource));
+        const enabledRuleResources = getEnabledResources(resolvedPaths.rules).filter((resource) => !isLocalProjectInstructionResource(resource));
+        const enabledPromptResources = getEnabledResources(resolvedPaths.prompts).filter((resource) => !isLocalProjectInstructionResource(resource));
+        const enabledPrompts = enabledPromptResources.map((resource) => resource.path);
         const enabledThemes = getEnabledPaths(resolvedPaths.themes);
         const mapSkillPath = (resource) => {
             if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
@@ -280,7 +378,41 @@ export class DefaultResourceLoader {
             }
             return resource.path;
         };
-        const enabledSkills = enabledSkillResources.map(mapSkillPath);
+        const instructionBackendType = instructionOperations?.getBackendInfo?.()?.type;
+        const discoveredRemoteInstructionResourcePaths = instructionOperations
+            ? this.getRemoteProjectInstructionResourcePaths(instructionOperations.cwd, instructionBackendType === "remote" ? "remote" : "ssh")
+            : { skills: [], rules: [], prompts: [] };
+        const filterExistingRemoteInstructionPaths = async (entries) => {
+            if (!instructionOperations)
+                return [];
+            const existing = [];
+            for (const entry of entries) {
+                try {
+                    await instructionOperations.access(entry.path, "exists");
+                    existing.push(entry);
+                }
+                catch { }
+            }
+            return existing;
+        };
+        const remoteInstructionResourcePaths = instructionOperations
+            ? {
+                skills: await filterExistingRemoteInstructionPaths(discoveredRemoteInstructionResourcePaths.skills),
+                rules: await filterExistingRemoteInstructionPaths(discoveredRemoteInstructionResourcePaths.rules),
+                prompts: await filterExistingRemoteInstructionPaths(discoveredRemoteInstructionResourcePaths.prompts),
+            }
+            : discoveredRemoteInstructionResourcePaths;
+        for (const entry of [
+            ...remoteInstructionResourcePaths.skills,
+            ...remoteInstructionResourcePaths.rules,
+            ...remoteInstructionResourcePaths.prompts,
+        ]) {
+            metadataByPath.set(entry.path, entry.metadata);
+        }
+        const enabledSkills = [
+            ...enabledSkillResources.map(mapSkillPath),
+            ...remoteInstructionResourcePaths.skills.map((entry) => entry.path),
+        ];
         const mapRulePath = (resource) => {
             if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
                 return resource.path;
@@ -303,7 +435,10 @@ export class DefaultResourceLoader {
             }
             return resource.path;
         };
-        const enabledRules = enabledRuleResources.map(mapRulePath);
+        const enabledRules = [
+            ...enabledRuleResources.map(mapRulePath),
+            ...remoteInstructionResourcePaths.rules.map((entry) => entry.path),
+        ];
         // Add CLI paths metadata
         for (const r of cliExtensionPaths.extensions) {
             if (!metadataByPath.has(r.path)) {
@@ -352,7 +487,7 @@ export class DefaultResourceLoader {
             ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths)
             : this.mergePaths([...cliEnabledSkills, ...enabledSkills], this.additionalSkillPaths);
         this.lastSkillPaths = skillPaths;
-        this.updateSkillsFromPaths(skillPaths, metadataByPath);
+        await this.updateSkillsFromPathsForReload(skillPaths, metadataByPath);
         for (const p of this.additionalSkillPaths) {
             if (isLocalPath(p)) {
                 const resolved = this.resolveResourcePath(p);
@@ -365,7 +500,7 @@ export class DefaultResourceLoader {
             ? this.mergePaths(cliEnabledRules, this.additionalRulePaths)
             : this.mergePaths([...cliEnabledRules, ...enabledRules], this.additionalRulePaths);
         this.lastRulePaths = rulePaths;
-        this.updateRulesFromPaths(rulePaths, metadataByPath);
+        await this.updateRulesFromPathsForReload(rulePaths, metadataByPath);
         for (const p of this.additionalRulePaths) {
             if (isLocalPath(p)) {
                 const resolved = this.resolveResourcePath(p);
@@ -374,11 +509,12 @@ export class DefaultResourceLoader {
                 }
             }
         }
+        const remotePromptPaths = remoteInstructionResourcePaths.prompts.map((entry) => entry.path);
         const promptPaths = this.noPromptTemplates
             ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths)
-            : this.mergePaths([...cliEnabledPrompts, ...enabledPrompts], this.additionalPromptTemplatePaths);
+            : this.mergePaths([...cliEnabledPrompts, ...enabledPrompts, ...remotePromptPaths], this.additionalPromptTemplatePaths);
         this.lastPromptPaths = promptPaths;
-        this.updatePromptsFromPaths(promptPaths, metadataByPath);
+        await this.updatePromptsFromPathsForReload(promptPaths, metadataByPath);
         for (const p of this.additionalPromptTemplatePaths) {
             if (isLocalPath(p)) {
                 const resolved = this.resolveResourcePath(p);
@@ -403,17 +539,23 @@ export class DefaultResourceLoader {
             }
         }
         const agentsFiles = {
-            agentsFiles: this.noContextFiles ? [] : loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }),
+            agentsFiles: this.noContextFiles
+                ? []
+                : instructionOperations
+                    ? await loadProjectContextFilesWithOperations({
+                        cwd: instructionOperations.cwd,
+                        agentDir: this.agentDir,
+                        operations: instructionOperations,
+                    })
+                    : loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }),
         };
         const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
         this.agentsFiles = resolvedAgentsFiles.agentsFiles;
-        const baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
+        const baseSystemPrompt = await resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt", this.getInstructionOperations());
         this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
         const appendSources = this.appendSystemPromptSource ??
             (this.discoverAppendSystemPromptFile() ? [this.discoverAppendSystemPromptFile()] : []);
-        const baseAppend = appendSources
-            .map((s) => resolvePromptInput(s, "append system prompt"))
-            .filter((s) => s !== undefined);
+        const baseAppend = (await Promise.all(appendSources.map((s) => resolvePromptInput(s, "append system prompt", this.getInstructionOperations())))).filter((s) => s !== undefined);
         this.appendSystemPrompt = this.appendSystemPromptOverride
             ? this.appendSystemPromptOverride(baseAppend)
             : baseAppend;
@@ -429,6 +571,31 @@ export class DefaultResourceLoader {
             };
         });
     }
+    getExtensionRegisteredSkills() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.skills.values()));
+    }
+    getExtensionRegisteredRules() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.rules.values()));
+    }
+    getExtensionRegisteredPrompts() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.prompts.values()));
+    }
+    applyLoadedSkills(skillsResult, metadataByPath) {
+        const extensionSkills = this.getExtensionRegisteredSkills();
+        const seenSkillNames = new Set(extensionSkills.map((skill) => skill.name));
+        const baseSkillsResult = {
+            skills: [...extensionSkills, ...skillsResult.skills.filter((skill) => !seenSkillNames.has(skill.name))],
+            diagnostics: skillsResult.diagnostics,
+        };
+        const resolvedSkills = this.skillsOverride ? this.skillsOverride(baseSkillsResult) : baseSkillsResult;
+        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;
+    }
     updateSkillsFromPaths(skillPaths, metadataByPath) {
         let skillsResult;
         if (this.noSkills && skillPaths.length === 0) {
@@ -442,14 +609,76 @@ export class DefaultResourceLoader {
                 includeDefaults: false,
             });
         }
-        const resolvedSkills = this.skillsOverride ? this.skillsOverride(skillsResult) : skillsResult;
-        this.skills = resolvedSkills.skills.map((skill) => ({
-            ...skill,
-            sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ??
-                skill.sourceInfo ??
-                this.getDefaultSourceInfoForPath(skill.filePath),
+        this.applyLoadedSkills(skillsResult, metadataByPath);
+    }
+    shouldLoadPathWithInstructionOperations(path, metadataByPath) {
+        const operations = this.getInstructionOperations();
+        if (!operations)
+            return false;
+        const sourceInfo = this.findSourceInfoForPath(path, undefined, metadataByPath);
+        if (sourceInfo?.source === "ssh" || sourceInfo?.source === "remote")
+            return true;
+        const cwd = operations.cwd.endsWith(sep) ? operations.cwd : `${operations.cwd}${sep}`;
+        return path === operations.cwd || path.startsWith(cwd);
+    }
+    async updateSkillsFromPathsForReload(skillPaths, metadataByPath) {
+        let skillsResult;
+        const operations = this.getInstructionOperations();
+        if (this.noSkills && skillPaths.length === 0) {
+            skillsResult = { skills: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = skillPaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = skillPaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remoteResult = await loadSkillsWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                skillPaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localResult = loadSkills({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                skillPaths: localPaths,
+                includeDefaults: false,
+            });
+            const skillsByName = new Map();
+            for (const skill of [...remoteResult.skills, ...localResult.skills]) {
+                if (!skillsByName.has(skill.name)) {
+                    skillsByName.set(skill.name, skill);
+                }
+            }
+            skillsResult = {
+                skills: Array.from(skillsByName.values()),
+                diagnostics: [...remoteResult.diagnostics, ...localResult.diagnostics],
+            };
+        }
+        else {
+            skillsResult = loadSkills({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                skillPaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedSkills(skillsResult, metadataByPath);
+    }
+    applyLoadedRules(rulesResult, metadataByPath) {
+        const extensionRules = this.getExtensionRegisteredRules();
+        const seenRuleNames = new Set(extensionRules.map((rule) => rule.name));
+        const baseRulesResult = {
+            rules: [...extensionRules, ...rulesResult.rules.filter((rule) => !seenRuleNames.has(rule.name))],
+            diagnostics: rulesResult.diagnostics,
+        };
+        const resolvedRules = this.rulesOverride ? this.rulesOverride(baseRulesResult) : baseRulesResult;
+        this.rules = resolvedRules.rules.map((rule) => ({
+            ...rule,
+            sourceInfo: this.findSourceInfoForPath(rule.filePath, this.extensionRuleSourceInfos, metadataByPath) ??
+                rule.sourceInfo ??
+                this.getDefaultSourceInfoForPath(rule.filePath),
         }));
-        this.skillDiagnostics = resolvedSkills.diagnostics;
+        this.ruleDiagnostics = resolvedRules.diagnostics;
     }
     updateRulesFromPaths(rulePaths, metadataByPath) {
         let rulesResult;
@@ -464,14 +693,63 @@ export class DefaultResourceLoader {
                 includeDefaults: false,
             });
         }
-        const resolvedRules = this.rulesOverride ? this.rulesOverride(rulesResult) : rulesResult;
-        this.rules = resolvedRules.rules.map((rule) => ({
-            ...rule,
-            sourceInfo: this.findSourceInfoForPath(rule.filePath, this.extensionRuleSourceInfos, metadataByPath) ??
-                rule.sourceInfo ??
-                this.getDefaultSourceInfoForPath(rule.filePath),
+        this.applyLoadedRules(rulesResult, metadataByPath);
+    }
+    async updateRulesFromPathsForReload(rulePaths, metadataByPath) {
+        let rulesResult;
+        const operations = this.getInstructionOperations();
+        if (this.noRules && rulePaths.length === 0) {
+            rulesResult = { rules: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = rulePaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = rulePaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remoteResult = await loadRulesWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                rulePaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localResult = loadRules({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                rulePaths: localPaths,
+                includeDefaults: false,
+            });
+            const rulesByName = new Map();
+            for (const rule of [...remoteResult.rules, ...localResult.rules]) {
+                if (!rulesByName.has(rule.name)) {
+                    rulesByName.set(rule.name, rule);
+                }
+            }
+            rulesResult = {
+                rules: Array.from(rulesByName.values()),
+                diagnostics: [...remoteResult.diagnostics, ...localResult.diagnostics],
+            };
+        }
+        else {
+            rulesResult = loadRules({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                rulePaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedRules(rulesResult, metadataByPath);
+    }
+    applyLoadedPrompts(promptsResult, metadataByPath) {
+        const extensionPrompts = this.getExtensionRegisteredPrompts();
+        const basePromptsResult = this.dedupePrompts([...extensionPrompts, ...promptsResult.prompts]);
+        basePromptsResult.diagnostics.unshift(...promptsResult.diagnostics);
+        const resolvedPrompts = this.promptsOverride ? this.promptsOverride(basePromptsResult) : basePromptsResult;
+        this.prompts = resolvedPrompts.prompts.map((prompt) => ({
+            ...prompt,
+            sourceInfo: this.findSourceInfoForPath(prompt.filePath, this.extensionPromptSourceInfos, metadataByPath) ??
+                prompt.sourceInfo ??
+                this.getDefaultSourceInfoForPath(prompt.filePath),
         }));
-        this.ruleDiagnostics = resolvedRules.diagnostics;
+        this.promptDiagnostics = resolvedPrompts.diagnostics;
     }
     updatePromptsFromPaths(promptPaths, metadataByPath) {
         let promptsResult;
@@ -487,14 +765,42 @@ export class DefaultResourceLoader {
             });
             promptsResult = this.dedupePrompts(allPrompts);
         }
-        const resolvedPrompts = this.promptsOverride ? this.promptsOverride(promptsResult) : promptsResult;
-        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.applyLoadedPrompts(promptsResult, metadataByPath);
+    }
+    async updatePromptsFromPathsForReload(promptPaths, metadataByPath) {
+        let promptsResult;
+        const operations = this.getInstructionOperations();
+        if (this.noPromptTemplates && promptPaths.length === 0) {
+            promptsResult = { prompts: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = promptPaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = promptPaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remotePrompts = await loadPromptTemplatesWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                promptPaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localPrompts = loadPromptTemplates({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                promptPaths: localPaths,
+                includeDefaults: false,
+            });
+            promptsResult = this.dedupePrompts([...remotePrompts, ...localPrompts]);
+        }
+        else {
+            const allPrompts = loadPromptTemplates({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                promptPaths,
+                includeDefaults: false,
+            });
+            promptsResult = this.dedupePrompts(allPrompts);
+        }
+        this.applyLoadedPrompts(promptsResult, metadataByPath);
     }
     updateThemesFromPaths(themePaths, metadataByPath) {
         let themesResult;
@@ -529,6 +835,15 @@ export class DefaultResourceLoader {
             for (const tool of extension.tools.values()) {
                 tool.sourceInfo = extension.sourceInfo;
             }
+            for (const skill of extension.skills.values()) {
+                skill.sourceInfo = extension.sourceInfo;
+            }
+            for (const rule of extension.rules.values()) {
+                rule.sourceInfo = extension.sourceInfo;
+            }
+            for (const prompt of extension.prompts.values()) {
+                prompt.sourceInfo = extension.sourceInfo;
+            }
         }
     }
     findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {