@ai-agent-forge/agent-forge 0.85.0

package/dist/core/resource-loader.js

@@ -0,0 +1,687 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import chalk from "chalk";
+import { CONFIG_DIR_NAME } from "../config.js";
+import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
+import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
+import { findGitPaths } from "./footer-data-provider.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";
+function resolvePromptInput(input, description) {
+    if (!input) {
+        return undefined;
+    }
+    if (existsSync(input)) {
+        try {
+            return stripBom(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.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+    for (const filename of candidates) {
+        const filePath = join(dir, filename);
+        if (existsSync(filePath)) {
+            try {
+                if (!statSync(filePath).isFile()) {
+                    continue;
+                }
+                return {
+                    path: filePath,
+                    content: stripBom(readFileSync(filePath, "utf-8")),
+                };
+            }
+            catch (error) {
+                console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The main repo's context file that a nested linked worktree's own copy shadows: both
+ * occupy the same logical repository scope, so loading both applies that context twice. Returns
+ * undefined when nothing is shadowed, leaving normal ancestor inheritance alone.
+ *
+ * Returned canonicalized (realpath), because `git worktree add` writes the `.git`
+ * file's `gitdir:` target in realpath form while cwd may still be symlinked
+ * (macOS `/tmp` -> `/private/tmp`).
+ */
+function findShadowedContextFile(cwd) {
+    const gitPaths = findGitPaths(cwd);
+    if (!gitPaths)
+        return undefined;
+    const commonGitDir = canonicalizePath(gitPaths.commonGitDir);
+    const worktreeRoot = canonicalizePath(gitPaths.repoDir);
+    const mainRepoRoot = dirname(commonGitDir);
+    // False for an ordinary repo, where the two are the same dir, and for a sibling
+    // worktree (`git worktree add ../feat`), whose main repo is not an ancestor.
+    if (!worktreeRoot.startsWith(`${mainRepoRoot}${sep}`))
+        return undefined;
+    // dirname of the common git dir is the main worktree root only when that dir is
+    // itself checked out from the same repo. In a bare layout (`proj/.bare` +
+    // `proj/main`) it is just the directory holding `.bare`, which tracks nothing; a
+    // submodule's gitdir has no `commondir`, so it lands under `.git/modules`.
+    if (canonicalizePath(join(mainRepoRoot, ".git")) !== commonGitDir)
+        return undefined;
+    const worktreeContextFile = loadContextFileFromDir(worktreeRoot);
+    return worktreeContextFile ? join(mainRepoRoot, basename(worktreeContextFile.path)) : undefined;
+}
+export function loadProjectContextFiles(options) {
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvedAgentDir);
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const ancestorContextFiles = [];
+    const shadowedContextFile = findShadowedContextFile(resolvedCwd);
+    let currentDir = resolvedCwd;
+    while (true) {
+        const contextFile = loadContextFileFromDir(currentDir);
+        const isShadowed = shadowedContextFile !== undefined && canonicalizePath(contextFile?.path ?? "") === shadowedContextFile;
+        if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    return contextFiles;
+}
+export class DefaultResourceLoader {
+    cwd;
+    agentDir;
+    settingsManager;
+    packageManager;
+    additionalSkillPaths;
+    additionalPromptTemplatePaths;
+    additionalThemePaths;
+    noSkills;
+    noPromptTemplates;
+    noThemes;
+    noContextFiles;
+    systemPromptSource;
+    appendSystemPromptSource;
+    skillsOverride;
+    promptsOverride;
+    themesOverride;
+    agentsFilesOverride;
+    systemPromptOverride;
+    appendSystemPromptOverride;
+    skills;
+    skillDiagnostics;
+    prompts;
+    promptDiagnostics;
+    themes;
+    themeDiagnostics;
+    agentsFiles;
+    systemPrompt;
+    systemPromptSourcePath;
+    appendSystemPrompt;
+    appendSystemPromptSourcePaths;
+    lastSkillPaths;
+    extensionSkillSourceInfos;
+    extensionPromptSourceInfos;
+    extensionThemeSourceInfos;
+    resourceMetadataByPath;
+    lastPromptPaths;
+    lastThemePaths;
+    constructor(options) {
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
+        this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir);
+        this.packageManager = new DefaultPackageManager({
+            cwd: this.cwd,
+            agentDir: this.agentDir,
+            settingsManager: this.settingsManager,
+        });
+        this.additionalSkillPaths = options.additionalSkillPaths ?? [];
+        this.additionalPromptTemplatePaths = options.additionalPromptTemplatePaths ?? [];
+        this.additionalThemePaths = options.additionalThemePaths ?? [];
+        this.noSkills = options.noSkills ?? false;
+        this.noPromptTemplates = options.noPromptTemplates ?? false;
+        this.noThemes = options.noThemes ?? false;
+        this.noContextFiles = options.noContextFiles ?? false;
+        this.systemPromptSource = options.systemPrompt;
+        this.appendSystemPromptSource = options.appendSystemPrompt;
+        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.skills = [];
+        this.skillDiagnostics = [];
+        this.prompts = [];
+        this.promptDiagnostics = [];
+        this.themes = [];
+        this.themeDiagnostics = [];
+        this.agentsFiles = [];
+        this.appendSystemPrompt = [];
+        this.appendSystemPromptSourcePaths = [];
+        this.lastSkillPaths = [];
+        this.extensionSkillSourceInfos = new Map();
+        this.extensionPromptSourceInfos = new Map();
+        this.extensionThemeSourceInfos = new Map();
+        this.resourceMetadataByPath = new Map();
+        this.lastPromptPaths = [];
+        this.lastThemePaths = [];
+    }
+    getSkills() {
+        return { skills: this.skills.slice(), diagnostics: this.skillDiagnostics.slice() };
+    }
+    getPrompts() {
+        return { prompts: this.prompts.slice(), diagnostics: this.promptDiagnostics.slice() };
+    }
+    getThemes() {
+        return { themes: this.themes.slice(), diagnostics: this.themeDiagnostics.slice() };
+    }
+    getAgentsFiles() {
+        return { agentsFiles: this.agentsFiles.slice() };
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    getSystemPromptSource() {
+        return this.systemPromptSourcePath ? { path: this.systemPromptSourcePath } : undefined;
+    }
+    getAppendSystemPrompt() {
+        return this.appendSystemPrompt;
+    }
+    getAppendSystemPromptSources() {
+        return this.appendSystemPromptSourcePaths.map((path) => ({ path }));
+    }
+    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, this.resourceMetadataByPath);
+        }
+        if (promptPaths.length > 0) {
+            this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path));
+            this.updatePromptsFromPaths(this.lastPromptPaths, this.resourceMetadataByPath);
+        }
+        if (themePaths.length > 0) {
+            this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path));
+            this.updateThemesFromPaths(this.lastThemePaths, this.resourceMetadataByPath);
+        }
+    }
+    async reload(_options) {
+        // Always load the complete configured project and user resource set.
+        await this.settingsManager.reload();
+        const resolvedPaths = await this.packageManager.resolve();
+        // Kept on the instance so post-reload passes (extendResources) can still resolve package metadata.
+        this.resourceMetadataByPath = new Map();
+        const metadataByPath = this.resourceMetadataByPath;
+        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 enabledSkillResources = getEnabledResources(resolvedPaths.skills);
+        const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
+        const enabledThemes = getEnabledPaths(resolvedPaths.themes);
+        const enabledSkills = enabledSkillResources.map((resource) => this.mapSkillPath(resource, metadataByPath));
+        const skillPaths = this.noSkills
+            ? [...this.additionalSkillPaths]
+            : this.mergePaths(enabledSkills, this.additionalSkillPaths);
+        this.lastSkillPaths = skillPaths;
+        this.updateSkillsFromPaths(skillPaths, metadataByPath);
+        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.additionalPromptTemplatePaths]
+            : this.mergePaths(enabledPrompts, this.additionalPromptTemplatePaths);
+        this.lastPromptPaths = promptPaths;
+        this.updatePromptsFromPaths(promptPaths, metadataByPath);
+        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.additionalThemePaths]
+            : this.mergePaths(enabledThemes, this.additionalThemePaths);
+        this.lastThemePaths = themePaths;
+        this.updateThemesFromPaths(themePaths, metadataByPath);
+        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 agentsFiles = {
+            agentsFiles: this.noContextFiles
+                ? []
+                : loadProjectContextFiles({
+                    cwd: this.cwd,
+                    agentDir: this.agentDir,
+                }),
+        };
+        const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
+        this.agentsFiles = resolvedAgentsFiles.agentsFiles;
+        const systemPromptSource = this.systemPromptSource ?? this.discoverSystemPromptFile();
+        const baseSystemPrompt = resolvePromptInput(systemPromptSource, "system prompt");
+        this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
+        this.systemPromptSourcePath =
+            systemPromptSource && existsSync(systemPromptSource) ? resolvePath(systemPromptSource) : undefined;
+        let appendSources = this.appendSystemPromptSource;
+        if (!appendSources) {
+            const discoveredAppendSystemPromptFile = this.discoverAppendSystemPromptFile();
+            appendSources = discoveredAppendSystemPromptFile ? [discoveredAppendSystemPromptFile] : [];
+        }
+        const baseAppend = appendSources
+            .map((s) => resolvePromptInput(s, "append system prompt"))
+            .filter((s) => s !== undefined);
+        this.appendSystemPrompt = this.appendSystemPromptOverride
+            ? this.appendSystemPromptOverride(baseAppend)
+            : baseAppend;
+        this.appendSystemPromptSourcePaths = appendSources
+            .filter((source) => existsSync(source))
+            .map((source) => resolvePath(source));
+    }
+    mapSkillPath(resource, metadataByPath) {
+        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;
+    }
+    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 applySourceInfo = (skill) => ({
+            ...skill,
+            sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ??
+                skill.sourceInfo ??
+                this.getDefaultSourceInfoForPath(skill.filePath),
+        });
+        // Source info is applied before skillsOverride so the override sees each
+        // skill's resolved source scope (the suite association filter needs it),
+        // and again after it so entries injected by the override are covered too.
+        skillsResult = { skills: skillsResult.skills.map(applySourceInfo), diagnostics: skillsResult.diagnostics };
+        const resolvedSkills = this.skillsOverride ? this.skillsOverride(skillsResult) : skillsResult;
+        this.skills = resolvedSkills.skills.map(applySourceInfo);
+        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 loadedThemes;
+        let themeDiagnostics;
+        if (this.noThemes && themePaths.length === 0) {
+            loadedThemes = [];
+            themeDiagnostics = [];
+        }
+        else {
+            const loaded = this.loadThemes(themePaths, false);
+            const deduped = this.dedupeThemes(loaded.themes);
+            loadedThemes = deduped.themes;
+            themeDiagnostics = [...loaded.diagnostics, ...deduped.diagnostics];
+        }
+        // Theme instances are projected to ThemeMetaV1 (name/sourcePath/sourceInfo
+        // only, no renderable state); sourceInfo is attached when the meta is
+        // built — before themesOverride sees it — and again after it so entries
+        // injected by the override are covered too (same pattern as skills/
+        // prompts overrides). Theme instances are never mutated here.
+        const themesResult = {
+            themes: loadedThemes.map((theme) => this.buildThemeMeta(theme, metadataByPath)),
+            diagnostics: themeDiagnostics,
+        };
+        const resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
+        this.themes = resolvedThemes.themes.map((meta) => this.buildThemeMeta(meta, metadataByPath));
+        this.themeDiagnostics = resolvedThemes.diagnostics;
+    }
+    buildThemeMeta(source, metadataByPath) {
+        const sourcePath = source.sourcePath ?? "";
+        return {
+            name: source.name,
+            sourcePath,
+            sourceInfo: sourcePath
+                ? (this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ??
+                    source.sourceInfo ??
+                    this.getDefaultSourceInfoForPath(sourcePath))
+                : source.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 = [join(this.agentDir, "skills"), join(this.agentDir, "prompts"), join(this.agentDir, "themes")];
+        const projectRoots = [
+            join(this.cwd, CONFIG_DIR_NAME, "skills"),
+            join(this.cwd, CONFIG_DIR_NAME, "prompts"),
+            join(this.cwd, CONFIG_DIR_NAME, "themes"),
+        ];
+        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 = [join(this.agentDir, "themes"), join(this.cwd, CONFIG_DIR_NAME, "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 });
+        }
+    }
+    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 projectPath = join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
+        if (existsSync(projectPath)) {
+            return projectPath;
+        }
+        const globalPath = join(this.agentDir, "SYSTEM.md");
+        if (existsSync(globalPath)) {
+            return globalPath;
+        }
+        return undefined;
+    }
+    discoverAppendSystemPromptFile() {
+        const projectPath = join(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");
+        if (existsSync(projectPath)) {
+            return projectPath;
+        }
+        const globalPath = join(this.agentDir, "APPEND_SYSTEM.md");
+        if (existsSync(globalPath)) {
+            return globalPath;
+        }
+        return undefined;
+    }
+    isUnderPath(target, root) {
+        const normalizedRoot = resolve(root);
+        if (target === normalizedRoot) {
+            return true;
+        }
+        const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+        return target.startsWith(prefix);
+    }
+}
+//# sourceMappingURL=resource-loader.js.map