@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

package/dist/core/resource-loader.js

@@ -1,977 +1,3 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import chalk from "chalk";
-import { getAgentDir, getAgentDirs, getProjectConfigDirs } from "../config.js";
-import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
-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 { SettingsManager } from "./settings-manager.js";
-import { loadSkills } from "./skills.js";
-import { createSourceInfo } from "./source-info.js";
-import { endTimingSpan, startTimingSpan } from "./timings.js";
-function resolvePromptInput(input, description) {
-    if (!input) {
-        return undefined;
-    }
-    if (existsSync(input)) {
-        try {
-            return readFileSync(input, "utf-8");
-        }
-        catch (error) {
-            console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`));
-            return input;
-        }
-    }
-    return input;
-}
-function loadContextFileFromDir(dir) {
-    const candidates = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
-    for (const filename of candidates) {
-        const filePath = join(dir, filename);
-        if (existsSync(filePath)) {
-            try {
-                return {
-                    path: filePath,
-                    content: readFileSync(filePath, "utf-8"),
-                };
-            }
-            catch (error) {
-                console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
-            }
-        }
-    }
-    return null;
-}
-export function loadProjectContextFiles(options) {
-    const resolvedCwd = resolvePath(options.cwd);
-    const resolvedAgentDir = resolvePath(options.agentDir);
-    const contextFiles = [];
-    const seenPaths = new Set();
-    const contextAgentDirs = Array.from(new Set(resolvedAgentDir === getAgentDir() ? getAgentDirs() : [resolvedAgentDir])).reverse();
-    for (const agentDir of contextAgentDirs) {
-        const context = loadContextFileFromDir(agentDir);
-        if (context && !seenPaths.has(context.path)) {
-            contextFiles.push(context);
-            seenPaths.add(context.path);
-        }
-    }
-    const ancestorContextFiles = [];
-    if (options.projectTrusted === false) {
-        return contextFiles;
-    }
-    let currentDir = resolvedCwd;
-    const root = resolve("/");
-    while (true) {
-        const contextFile = loadContextFileFromDir(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;
-}
-function cloneStringArray(values) {
-    return values === undefined ? [] : [...values];
-}
-function mergeInheritedStrings(inherited, current) {
-    return [...cloneStringArray(inherited), ...cloneStringArray(current)];
-}
-function clonePackageSource(source) {
-    if (typeof source === "string") {
-        return source;
-    }
-    return {
-        source: source.source,
-        ...(source.extensions === undefined ? {} : { extensions: [...source.extensions] }),
-        ...(source.skills === undefined ? {} : { skills: [...source.skills] }),
-        ...(source.prompts === undefined ? {} : { prompts: [...source.prompts] }),
-        ...(source.themes === undefined ? {} : { themes: [...source.themes] }),
-        ...(source.workflows === undefined ? {} : { workflows: [...source.workflows] }),
-    };
-}
-function clonePackageSources(sources) {
-    return sources === undefined ? [] : sources.map((source) => clonePackageSource(source));
-}
-export class DefaultResourceLoader {
-    constructor(options) {
-        const inheritanceSnapshot = options.resourceLoaderInheritanceSnapshot;
-        const inheritedSettingsOptions = inheritanceSnapshot?.projectTrusted === undefined
-            ? undefined
-            : { projectTrusted: inheritanceSnapshot.projectTrusted };
-        this.cwd = resolvePath(options.cwd);
-        this.agentDir = resolvePath(options.agentDir);
-        this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir, inheritedSettingsOptions);
-        this.eventBus = options.eventBus ?? createEventBus();
-        this.packageManager = new DefaultPackageManager({
-            cwd: this.cwd,
-            agentDir: this.agentDir,
-            settingsManager: this.settingsManager,
-        });
-        this.additionalExtensionPaths = mergeInheritedStrings(inheritanceSnapshot?.additionalExtensionPaths, options.additionalExtensionPaths);
-        this.additionalSkillPaths = mergeInheritedStrings(inheritanceSnapshot?.additionalSkillPaths, options.additionalSkillPaths);
-        this.additionalPromptTemplatePaths = mergeInheritedStrings(inheritanceSnapshot?.additionalPromptTemplatePaths, options.additionalPromptTemplatePaths);
-        this.additionalThemePaths = mergeInheritedStrings(inheritanceSnapshot?.additionalThemePaths, options.additionalThemePaths);
-        this.builtinPackagePaths = options.builtinPackagePaths !== undefined
-            ? clonePackageSources(options.builtinPackagePaths)
-            : clonePackageSources(inheritanceSnapshot?.builtinPackagePaths);
-        this.extensionFactories = [
-            ...(inheritanceSnapshot?.extensionFactories ?? []),
-            ...(options.extensionFactories ?? []),
-        ];
-        this.noExtensions = options.noExtensions ?? inheritanceSnapshot?.noExtensions ?? false;
-        this.noSkills = options.noSkills ?? inheritanceSnapshot?.noSkills ?? false;
-        this.noPromptTemplates = options.noPromptTemplates ?? inheritanceSnapshot?.noPromptTemplates ?? false;
-        this.noThemes = options.noThemes ?? inheritanceSnapshot?.noThemes ?? false;
-        this.noContextFiles = options.noContextFiles ?? inheritanceSnapshot?.noContextFiles ?? false;
-        this.systemPromptSource = options.systemPrompt ?? inheritanceSnapshot?.systemPrompt;
-        this.appendSystemPromptSource = options.appendSystemPrompt !== undefined
-            ? [...options.appendSystemPrompt]
-            : inheritanceSnapshot?.appendSystemPrompt === undefined
-                ? undefined
-                : [...inheritanceSnapshot.appendSystemPrompt];
-        this.extensionsOverride = options.extensionsOverride;
-        this.skillsOverride = options.skillsOverride;
-        this.promptsOverride = options.promptsOverride;
-        this.themesOverride = options.themesOverride;
-        this.agentsFilesOverride = options.agentsFilesOverride;
-        this.systemPromptOverride = options.systemPromptOverride;
-        this.appendSystemPromptOverride = options.appendSystemPromptOverride;
-        this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
-        this.skills = [];
-        this.skillDiagnostics = [];
-        this.prompts = [];
-        this.promptDiagnostics = [];
-        this.themes = [];
-        this.themeDiagnostics = [];
-        this.agentsFiles = [];
-        this.appendSystemPrompt = [];
-        this.workflowResources = [];
-        this.trustedBorrowedProjectLocalSources = inheritanceSnapshot?.trustedBorrowedProjectLocalSources === undefined
-            ? undefined
-            : new Set(inheritanceSnapshot.trustedBorrowedProjectLocalSources);
-        this.lastSkillPaths = [];
-        this.extensionSkillSourceInfos = new Map();
-        this.extensionPromptSourceInfos = new Map();
-        this.extensionThemeSourceInfos = new Map();
-        this.lastPromptPaths = [];
-        this.lastThemePaths = [];
-    }
-    getExtensions() {
-        return this.extensionsResult;
-    }
-    getSkills() {
-        return { skills: this.skills, diagnostics: this.skillDiagnostics };
-    }
-    getPrompts() {
-        return { prompts: this.prompts, diagnostics: this.promptDiagnostics };
-    }
-    getThemes() {
-        return { themes: this.themes, diagnostics: this.themeDiagnostics };
-    }
-    getAgentsFiles() {
-        return { agentsFiles: this.agentsFiles };
-    }
-    getSystemPrompt() {
-        return this.systemPrompt;
-    }
-    getAppendSystemPrompt() {
-        return this.appendSystemPrompt;
-    }
-    getWorkflowResources() {
-        return [...this.workflowResources];
-    }
-    getInheritanceSnapshot() {
-        return {
-            projectTrusted: this.settingsManager.isProjectTrusted(),
-            additionalExtensionPaths: [...this.additionalExtensionPaths],
-            additionalSkillPaths: [...this.additionalSkillPaths],
-            additionalPromptTemplatePaths: [...this.additionalPromptTemplatePaths],
-            additionalThemePaths: [...this.additionalThemePaths],
-            builtinPackagePaths: clonePackageSources(this.builtinPackagePaths),
-            extensionFactories: [...this.extensionFactories],
-            noExtensions: this.noExtensions,
-            noSkills: this.noSkills,
-            noPromptTemplates: this.noPromptTemplates,
-            noThemes: this.noThemes,
-            noContextFiles: this.noContextFiles,
-            ...(this.systemPromptSource === undefined ? {} : { systemPrompt: this.systemPromptSource }),
-            ...(this.appendSystemPromptSource === undefined
-                ? {}
-                : { appendSystemPrompt: [...this.appendSystemPromptSource] }),
-            ...(this.trustedBorrowedProjectLocalSources === undefined
-                ? {}
-                : { trustedBorrowedProjectLocalSources: [...this.trustedBorrowedProjectLocalSources] }),
-        };
-    }
-    async refreshWorkflowResources() {
-        const { resolvedPaths, cliExtensionPaths, builtinPackagePaths } = await this.resolvePackageResourcePaths({
-            trustedBorrowedProjectLocalSources: this.trustedBorrowedProjectLocalSources,
-        });
-        const workflowResources = this.collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths);
-        this.workflowResources = workflowResources;
-        return [...this.workflowResources];
-    }
-    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);
-        }
-        if (promptPaths.length > 0) {
-            this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path));
-            this.updatePromptsFromPaths(this.lastPromptPaths);
-        }
-        if (themePaths.length > 0) {
-            this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path));
-            this.updateThemesFromPaths(this.lastThemePaths);
-        }
-    }
-    async loadProjectTrustExtensions() {
-        this.settingsManager.setProjectTrusted(false);
-        await this.settingsManager.reload();
-        const { resolvedPaths, cliExtensionPaths, builtinPackagePaths } = await this.resolvePackageResourcePaths({
-            includeCliProjectLocalResources: false,
-        });
-        const metadataByPath = new Map();
-        const getEnabledResources = (resources) => {
-            for (const r of resources) {
-                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);
-        const cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions);
-        const enabledExtensions = getEnabledPaths(resolvedPaths.extensions);
-        const builtinEnabledExtensions = this.noExtensions ? [] : getEnabledPaths(builtinPackagePaths.extensions);
-        const workflowResources = this.collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths);
-        this.workflowResources = workflowResources;
-        const workflowResourceProvider = this.createWorkflowResourceProvider();
-        const inheritanceSnapshotProvider = this.createInheritanceSnapshotProvider();
-        const extensionPaths = this.noExtensions
-            ? cliEnabledExtensions
-            : this.mergePaths(cliEnabledExtensions, [...enabledExtensions, ...builtinEnabledExtensions]);
-        const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus, workflowResourceProvider, undefined, inheritanceSnapshotProvider);
-        const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime, workflowResourceProvider, inheritanceSnapshotProvider);
-        extensionsResult.extensions.push(...inlineExtensions.extensions);
-        extensionsResult.errors.push(...inlineExtensions.errors);
-        this.applyExtensionSourceInfo(extensionsResult.extensions, metadataByPath);
-        return extensionsResult;
-    }
-    async reload(options) {
-        let preTrustExtensions;
-        const initialProjectTrusted = this.settingsManager.isProjectTrusted();
-        if (options?.resolveProjectTrust || options?.resolveBorrowedProjectTrust) {
-            preTrustExtensions = await this.loadProjectTrustExtensions();
-        }
-        if (options?.resolveProjectTrust && preTrustExtensions) {
-            const projectTrusted = await options.resolveProjectTrust({ extensionsResult: preTrustExtensions });
-            this.settingsManager.setProjectTrusted(projectTrusted);
-        }
-        else if (preTrustExtensions) {
-            this.settingsManager.setProjectTrusted(initialProjectTrusted);
-        }
-        if (options?.resolveBorrowedProjectTrust) {
-            this.trustedBorrowedProjectLocalSources = await this.resolveTrustedBorrowedProjectLocalSources(options.resolveBorrowedProjectTrust, preTrustExtensions);
-        }
-        const resolveSpan = startTimingSpan("DefaultResourceLoader.reload.resolvePackageResourcePaths");
-        const { resolvedPaths, cliExtensionPaths, builtinPackagePaths } = await this.resolvePackageResourcePaths({
-            trustedBorrowedProjectLocalSources: this.trustedBorrowedProjectLocalSources,
-        });
-        endTimingSpan(resolveSpan);
-        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 (!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);
-        const enabledExtensions = getEnabledPaths(resolvedPaths.extensions);
-        const enabledSkillResources = getEnabledResources(resolvedPaths.skills);
-        const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
-        const enabledThemes = getEnabledPaths(resolvedPaths.themes);
-        const builtinEnabledExtensions = this.noExtensions
-            ? []
-            : getEnabledPaths(builtinPackagePaths.extensions);
-        const builtinEnabledSkillResources = this.noSkills ? [] : getEnabledResources(builtinPackagePaths.skills);
-        const builtinEnabledPrompts = this.noPromptTemplates ? [] : getEnabledPaths(builtinPackagePaths.prompts);
-        const builtinEnabledThemes = this.noThemes ? [] : getEnabledPaths(builtinPackagePaths.themes);
-        const mapSkillPath = (resource) => {
-            if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
-                return resource.path;
-            }
-            try {
-                const stats = statSync(resource.path);
-                if (!stats.isDirectory()) {
-                    return resource.path;
-                }
-            }
-            catch {
-                return resource.path;
-            }
-            const skillFile = join(resource.path, "SKILL.md");
-            if (existsSync(skillFile)) {
-                if (!metadataByPath.has(skillFile)) {
-                    metadataByPath.set(skillFile, resource.metadata);
-                }
-                return skillFile;
-            }
-            return resource.path;
-        };
-        const enabledSkills = enabledSkillResources.map(mapSkillPath);
-        const builtinEnabledSkills = builtinEnabledSkillResources.map(mapSkillPath);
-        // Add CLI paths metadata
-        for (const r of cliExtensionPaths.extensions) {
-            if (!metadataByPath.has(r.path)) {
-                metadataByPath.set(r.path, r.metadata);
-            }
-        }
-        for (const r of cliExtensionPaths.skills) {
-            if (!metadataByPath.has(r.path)) {
-                metadataByPath.set(r.path, r.metadata);
-            }
-        }
-        const cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions);
-        const cliEnabledSkills = getEnabledPaths(cliExtensionPaths.skills);
-        const cliEnabledPrompts = getEnabledPaths(cliExtensionPaths.prompts);
-        const cliEnabledThemes = getEnabledPaths(cliExtensionPaths.themes);
-        const workflowResources = this.collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths);
-        this.workflowResources = workflowResources;
-        const workflowResourceProvider = this.createWorkflowResourceProvider();
-        const extensionPaths = this.noExtensions
-            ? cliEnabledExtensions
-            : this.mergePaths(cliEnabledExtensions, [...enabledExtensions, ...builtinEnabledExtensions]);
-        const inheritanceSnapshotProvider = this.createInheritanceSnapshotProvider();
-        const extensionsResult = await this.loadFinalExtensionSet(extensionPaths, preTrustExtensions, workflowResourceProvider, inheritanceSnapshotProvider);
-        for (const p of this.additionalExtensionPaths) {
-            if (isLocalPath(p)) {
-                const resolved = this.resolveResourcePath(p);
-                if (!existsSync(resolved)) {
-                    extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
-                }
-            }
-        }
-        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([...cliEnabledSkills, ...enabledSkills, ...builtinEnabledSkills], this.additionalSkillPaths);
-        this.lastSkillPaths = skillPaths;
-        const skillsSpan = startTimingSpan("DefaultResourceLoader.reload.updateSkillsFromPaths");
-        this.updateSkillsFromPaths(skillPaths, metadataByPath);
-        endTimingSpan(skillsSpan);
-        for (const p of this.additionalSkillPaths) {
-            if (isLocalPath(p)) {
-                const resolved = this.resolveResourcePath(p);
-                if (!existsSync(resolved) && !this.skillDiagnostics.some((d) => d.path === resolved)) {
-                    this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: resolved });
-                }
-            }
-        }
-        const promptPaths = this.noPromptTemplates
-            ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths)
-            : this.mergePaths([...cliEnabledPrompts, ...enabledPrompts, ...builtinEnabledPrompts], this.additionalPromptTemplatePaths);
-        this.lastPromptPaths = promptPaths;
-        const promptsSpan = startTimingSpan("DefaultResourceLoader.reload.updatePromptsFromPaths");
-        this.updatePromptsFromPaths(promptPaths, metadataByPath);
-        endTimingSpan(promptsSpan);
-        for (const p of this.additionalPromptTemplatePaths) {
-            if (isLocalPath(p)) {
-                const resolved = this.resolveResourcePath(p);
-                if (!existsSync(resolved) && !this.promptDiagnostics.some((d) => d.path === resolved)) {
-                    this.promptDiagnostics.push({
-                        type: "error",
-                        message: "Prompt template path does not exist",
-                        path: resolved,
-                    });
-                }
-            }
-        }
-        const themePaths = this.noThemes
-            ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths)
-            : this.mergePaths([...cliEnabledThemes, ...enabledThemes, ...builtinEnabledThemes], this.additionalThemePaths);
-        this.lastThemePaths = themePaths;
-        const themesSpan = startTimingSpan("DefaultResourceLoader.reload.updateThemesFromPaths");
-        this.updateThemesFromPaths(themePaths, metadataByPath);
-        endTimingSpan(themesSpan);
-        for (const p of this.additionalThemePaths) {
-            const resolved = this.resolveResourcePath(p);
-            if (!existsSync(resolved) && !this.themeDiagnostics.some((d) => d.path === resolved)) {
-                this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: resolved });
-            }
-        }
-        const contextFilesSpan = startTimingSpan("DefaultResourceLoader.reload.loadProjectContextFiles");
-        const agentsFiles = {
-            agentsFiles: this.noContextFiles
-                ? []
-                : loadProjectContextFiles({
-                    cwd: this.cwd,
-                    agentDir: this.agentDir,
-                    projectTrusted: this.settingsManager.isProjectTrusted(),
-                }),
-        };
-        endTimingSpan(contextFilesSpan);
-        const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
-        this.agentsFiles = resolvedAgentsFiles.agentsFiles;
-        const promptFilesSpan = startTimingSpan("DefaultResourceLoader.reload.resolvePromptFiles");
-        const baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
-        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);
-        this.appendSystemPrompt = this.appendSystemPromptOverride
-            ? this.appendSystemPromptOverride(baseAppend)
-            : baseAppend;
-        endTimingSpan(promptFilesSpan);
-    }
-    emptyResolvedPaths() {
-        return { extensions: [], skills: [], prompts: [], themes: [], workflows: [] };
-    }
-    async resolvePackageResourcePaths(options) {
-        await this.settingsManager.reload();
-        const resolvedPaths = await this.packageManager.resolve();
-        const includeCliProjectLocalResources = options?.includeCliProjectLocalResources ?? true;
-        let cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
-            temporary: true,
-            includeProjectLocalResources: includeCliProjectLocalResources,
-        });
-        if (includeCliProjectLocalResources && options?.trustedBorrowedProjectLocalSources) {
-            cliExtensionPaths = this.filterBorrowedProjectLocalResources(cliExtensionPaths, options.trustedBorrowedProjectLocalSources);
-        }
-        const builtinPackagePaths = this.builtinPackagePaths.length > 0
-            ? await this.packageManager.resolveExtensionSources(this.builtinPackagePaths, { temporary: true })
-            : this.emptyResolvedPaths();
-        return { resolvedPaths, cliExtensionPaths, builtinPackagePaths };
-    }
-    async resolveTrustedBorrowedProjectLocalSources(resolveBorrowedProjectTrust, preTrustExtensions) {
-        const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
-            temporary: true,
-            includeProjectLocalResources: true,
-        });
-        const resourcesBySource = new Map();
-        for (const resources of Object.values(cliExtensionPaths)) {
-            for (const resource of resources) {
-                if (!resource.metadata.borrowedProjectLocal) {
-                    continue;
-                }
-                const sourceResources = resourcesBySource.get(resource.metadata.source) ?? [];
-                sourceResources.push(resource);
-                resourcesBySource.set(resource.metadata.source, sourceResources);
-            }
-        }
-        const trustedSources = new Set();
-        for (const [source, resources] of resourcesBySource) {
-            const trusted = await resolveBorrowedProjectTrust({
-                source,
-                resources,
-                extensionsResult: preTrustExtensions ?? { extensions: [], errors: [], runtime: createExtensionRuntime() },
-            });
-            if (trusted) {
-                trustedSources.add(source);
-            }
-        }
-        return trustedSources;
-    }
-    filterBorrowedProjectLocalResources(paths, trustedSources) {
-        const filterResources = (resources) => resources.filter((resource) => !resource.metadata.borrowedProjectLocal || trustedSources.has(resource.metadata.source));
-        return {
-            extensions: filterResources(paths.extensions),
-            skills: filterResources(paths.skills),
-            prompts: filterResources(paths.prompts),
-            themes: filterResources(paths.themes),
-            workflows: filterResources(paths.workflows),
-        };
-    }
-    enabledWorkflowResources(resources) {
-        return resources.filter((resource) => resource.enabled);
-    }
-    enabledPackageWorkflowResources(resources) {
-        return resources.filter((resource) => resource.enabled && resource.metadata.origin === "package");
-    }
-    collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths) {
-        return [
-            ...this.enabledWorkflowResources(cliExtensionPaths.workflows),
-            ...this.enabledPackageWorkflowResources(resolvedPaths.workflows),
-            ...this.enabledPackageWorkflowResources(builtinPackagePaths.workflows),
-        ];
-    }
-    createWorkflowResourceProvider() {
-        return {
-            get: () => this.workflowResources,
-            refresh: () => this.refreshWorkflowResources(),
-        };
-    }
-    createInheritanceSnapshotProvider() {
-        return () => this.getInheritanceSnapshot();
-    }
-    normalizeExtensionPaths(entries) {
-        return entries.map((entry) => {
-            const metadata = entry.metadata.baseDir
-                ? { ...entry.metadata, baseDir: this.resolveResourcePath(entry.metadata.baseDir) }
-                : entry.metadata;
-            return {
-                path: this.resolveResourcePath(entry.path),
-                metadata,
-            };
-        });
-    }
-    updateSkillsFromPaths(skillPaths, metadataByPath) {
-        let skillsResult;
-        if (this.noSkills && skillPaths.length === 0) {
-            skillsResult = { skills: [], diagnostics: [] };
-        }
-        else {
-            skillsResult = loadSkills({
-                cwd: this.cwd,
-                agentDir: this.agentDir,
-                skillPaths,
-                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.skillDiagnostics = resolvedSkills.diagnostics;
-    }
-    updatePromptsFromPaths(promptPaths, metadataByPath) {
-        let promptsResult;
-        if (this.noPromptTemplates && promptPaths.length === 0) {
-            promptsResult = { prompts: [], diagnostics: [] };
-        }
-        else {
-            const allPrompts = loadPromptTemplates({
-                cwd: this.cwd,
-                agentDir: this.agentDir,
-                promptPaths,
-                includeDefaults: false,
-            });
-            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;
-    }
-    updateThemesFromPaths(themePaths, metadataByPath) {
-        let themesResult;
-        if (this.noThemes && themePaths.length === 0) {
-            themesResult = { themes: [], diagnostics: [] };
-        }
-        else {
-            const loaded = this.loadThemes(themePaths, false);
-            const deduped = this.dedupeThemes(loaded.themes);
-            themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
-        }
-        const resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
-        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;
-    }
-    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;
-            }
-        }
-    }
-    findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {
-        if (!resourcePath) {
-            return undefined;
-        }
-        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 };
-                }
-            }
-        }
-        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 = this.getAgentDirs().flatMap((agentDir) => [
-            join(agentDir, "skills"),
-            join(agentDir, "prompts"),
-            join(agentDir, "themes"),
-            join(agentDir, "extensions"),
-        ]);
-        const projectRoots = getProjectConfigDirs(this.cwd).flatMap((configDir) => [
-            join(configDir, "skills"),
-            join(configDir, "prompts"),
-            join(configDir, "themes"),
-            join(configDir, "extensions"),
-        ]);
-        for (const root of agentRoots) {
-            if (this.isUnderPath(normalizedPath, root)) {
-                return { path: filePath, source: "local", scope: "user", origin: "top-level", baseDir: root };
-            }
-        }
-        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 = [];
-        const seen = new Set();
-        for (const p of [...primary, ...additional]) {
-            const resolved = this.resolveResourcePath(p);
-            const canonicalPath = canonicalizePath(resolved);
-            if (seen.has(canonicalPath))
-                continue;
-            seen.add(canonicalPath);
-            merged.push(resolved);
-        }
-        return merged;
-    }
-    resolveResourcePath(p) {
-        return resolvePath(p, this.cwd, { trim: true });
-    }
-    loadThemes(paths, includeDefaults = true) {
-        const themes = [];
-        const diagnostics = [];
-        if (includeDefaults) {
-            const defaultDirs = [
-                ...this.getAgentDirs().map((agentDir) => join(agentDir, "themes")),
-                ...getProjectConfigDirs(this.cwd).map((configDir) => join(configDir, "themes")),
-            ];
-            for (const dir of defaultDirs) {
-                this.loadThemesFromDir(dir, themes, diagnostics);
-            }
-        }
-        for (const p of paths) {
-            const resolved = this.resolveResourcePath(p);
-            if (!existsSync(resolved)) {
-                diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
-                continue;
-            }
-            try {
-                const stats = statSync(resolved);
-                if (stats.isDirectory()) {
-                    this.loadThemesFromDir(resolved, themes, diagnostics);
-                }
-                else if (stats.isFile() && resolved.endsWith(".json")) {
-                    this.loadThemeFromFile(resolved, themes, diagnostics);
-                }
-                else {
-                    diagnostics.push({ type: "warning", message: "theme path is not a json file", path: resolved });
-                }
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "failed to read theme path";
-                diagnostics.push({ type: "warning", message, path: resolved });
-            }
-        }
-        return { themes, diagnostics };
-    }
-    loadThemesFromDir(dir, themes, diagnostics) {
-        if (!existsSync(dir)) {
-            return;
-        }
-        try {
-            const entries = readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                let isFile = entry.isFile();
-                if (entry.isSymbolicLink()) {
-                    try {
-                        isFile = statSync(join(dir, entry.name)).isFile();
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-                if (!isFile) {
-                    continue;
-                }
-                if (!entry.name.endsWith(".json")) {
-                    continue;
-                }
-                this.loadThemeFromFile(join(dir, entry.name), themes, diagnostics);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "failed to read theme directory";
-            diagnostics.push({ type: "warning", message, path: dir });
-        }
-    }
-    loadThemeFromFile(filePath, themes, diagnostics) {
-        try {
-            themes.push(loadThemeFromPath(filePath));
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "failed to load theme";
-            diagnostics.push({ type: "warning", message, path: filePath });
-        }
-    }
-    resolveExtensionLoadPath(path) {
-        return resolvePath(path, this.cwd, { normalizeUnicodeSpaces: true });
-    }
-    async loadFinalExtensionSet(extensionPaths, preTrustExtensions, workflowResourceProvider, inheritanceSnapshotProvider) {
-        if (!preTrustExtensions) {
-            const loadExtensionsSpan = startTimingSpan("DefaultResourceLoader.reload.loadExtensions");
-            const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus, workflowResourceProvider, undefined, inheritanceSnapshotProvider);
-            endTimingSpan(loadExtensionsSpan);
-            const inlineExtensionsSpan = startTimingSpan("DefaultResourceLoader.reload.loadInlineExtensionFactories");
-            const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime, workflowResourceProvider, inheritanceSnapshotProvider);
-            endTimingSpan(inlineExtensionsSpan);
-            extensionsResult.extensions.push(...inlineExtensions.extensions);
-            extensionsResult.errors.push(...inlineExtensions.errors);
-            this.addExtensionConflictDiagnostics(extensionsResult);
-            return extensionsResult;
-        }
-        const preloadedByPath = new Map(preTrustExtensions.extensions
-            .filter((extension) => !extension.path.startsWith("<inline:"))
-            .map((extension) => [extension.resolvedPath, extension]));
-        const failedPreloadPaths = new Set(preTrustExtensions.errors.map((error) => this.resolveExtensionLoadPath(error.path)));
-        const remainingPaths = extensionPaths.filter((path) => {
-            const resolvedPath = this.resolveExtensionLoadPath(path);
-            return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
-        });
-        const loadExtensionsSpan = startTimingSpan("DefaultResourceLoader.reload.loadExtensions");
-        const remainingExtensions = await loadExtensions(remainingPaths, this.cwd, this.eventBus, workflowResourceProvider, preTrustExtensions.runtime, inheritanceSnapshotProvider);
-        endTimingSpan(loadExtensionsSpan);
-        const loadedByPath = new Map(preloadedByPath);
-        for (const extension of remainingExtensions.extensions) {
-            loadedByPath.set(extension.resolvedPath, extension);
-        }
-        const inlineExtensions = preTrustExtensions.extensions.filter((extension) => extension.path.startsWith("<inline:"));
-        const orderedExtensions = extensionPaths
-            .map((path) => loadedByPath.get(this.resolveExtensionLoadPath(path)))
-            .filter((extension) => extension !== undefined);
-        orderedExtensions.push(...inlineExtensions);
-        const extensionsResult = {
-            extensions: orderedExtensions,
-            errors: [...preTrustExtensions.errors, ...remainingExtensions.errors],
-            runtime: preTrustExtensions.runtime,
-        };
-        this.addExtensionConflictDiagnostics(extensionsResult);
-        return extensionsResult;
-    }
-    addExtensionConflictDiagnostics(extensionsResult) {
-        // Detect extension conflicts (tools, commands, flags with same names from different extensions)
-        // Keep all extensions loaded. Conflicts are reported as diagnostics, and precedence is handled by load order.
-        const conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
-        for (const conflict of conflicts) {
-            extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
-        }
-    }
-    async loadExtensionFactories(runtime, workflowResourceProvider, inheritanceSnapshotProvider) {
-        const extensions = [];
-        const errors = [];
-        for (const [index, factory] of this.extensionFactories.entries()) {
-            const extensionPath = `<inline:${index + 1}>`;
-            try {
-                const extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath, workflowResourceProvider, inheritanceSnapshotProvider);
-                extensions.push(extension);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "failed to load extension";
-                errors.push({ path: extensionPath, error: message });
-            }
-        }
-        return { extensions, errors };
-    }
-    dedupePrompts(prompts) {
-        const seen = new Map();
-        const diagnostics = [];
-        for (const prompt of prompts) {
-            const existing = seen.get(prompt.name);
-            if (existing) {
-                diagnostics.push({
-                    type: "collision",
-                    message: `name "/${prompt.name}" collision`,
-                    path: prompt.filePath,
-                    collision: {
-                        resourceType: "prompt",
-                        name: prompt.name,
-                        winnerPath: existing.filePath,
-                        loserPath: prompt.filePath,
-                    },
-                });
-            }
-            else {
-                seen.set(prompt.name, prompt);
-            }
-        }
-        return { prompts: Array.from(seen.values()), diagnostics };
-    }
-    dedupeThemes(themes) {
-        const seen = new Map();
-        const diagnostics = [];
-        for (const t of themes) {
-            const name = t.name ?? "unnamed";
-            const existing = seen.get(name);
-            if (existing) {
-                diagnostics.push({
-                    type: "collision",
-                    message: `name "${name}" collision`,
-                    path: t.sourcePath,
-                    collision: {
-                        resourceType: "theme",
-                        name,
-                        winnerPath: existing.sourcePath ?? "<builtin>",
-                        loserPath: t.sourcePath ?? "<builtin>",
-                    },
-                });
-            }
-            else {
-                seen.set(name, t);
-            }
-        }
-        return { themes: Array.from(seen.values()), diagnostics };
-    }
-    discoverSystemPromptFile() {
-        const projectCandidates = this.settingsManager.isProjectTrusted()
-            ? getProjectConfigDirs(this.cwd).map((configDir) => join(configDir, "SYSTEM.md"))
-            : [];
-        const candidates = [
-            ...projectCandidates,
-            ...this.getAgentDirs().map((agentDir) => join(agentDir, "SYSTEM.md")),
-        ];
-        return candidates.find((candidate) => existsSync(candidate));
-    }
-    discoverAppendSystemPromptFile() {
-        const projectCandidates = this.settingsManager.isProjectTrusted()
-            ? getProjectConfigDirs(this.cwd).map((configDir) => join(configDir, "APPEND_SYSTEM.md"))
-            : [];
-        const candidates = [
-            ...projectCandidates,
-            ...this.getAgentDirs().map((agentDir) => join(agentDir, "APPEND_SYSTEM.md")),
-        ];
-        return candidates.find((candidate) => existsSync(candidate));
-    }
-    getAgentDirs() {
-        return this.agentDir === getAgentDir() ? getAgentDirs() : [this.agentDir];
-    }
-    isUnderPath(target, root) {
-        const normalizedRoot = resolve(root);
-        if (target === normalizedRoot) {
-            return true;
-        }
-        const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
-        return target.startsWith(prefix);
-    }
-    detectExtensionConflicts(extensions) {
-        const conflicts = [];
-        // Track which extension registered each tool and flag
-        const toolOwners = new Map();
-        const flagOwners = new Map();
-        for (const ext of extensions) {
-            // Check tools
-            for (const toolName of ext.tools.keys()) {
-                const existingOwner = toolOwners.get(toolName);
-                if (existingOwner && existingOwner !== ext.path) {
-                    conflicts.push({
-                        path: ext.path,
-                        message: `Tool "${toolName}" conflicts with ${existingOwner}`,
-                    });
-                }
-                else {
-                    toolOwners.set(toolName, ext.path);
-                }
-            }
-            // Check flags
-            for (const flagName of ext.flags.keys()) {
-                const existingOwner = flagOwners.get(flagName);
-                if (existingOwner && existingOwner !== ext.path) {
-                    conflicts.push({
-                        path: ext.path,
-                        message: `Flag "--${flagName}" conflicts with ${existingOwner}`,
-                    });
-                }
-                else {
-                    flagOwners.set(flagName, ext.path);
-                }
-            }
-        }
-        return conflicts;
-    }
-}
+export { DefaultResourceLoader } from "./resource-loader-core.js";
+export { loadProjectContextFiles } from "./resource-loader-context-files.js";
 //# sourceMappingURL=resource-loader.js.map