indusagi-coding-agent 0.1.38 → 0.1.40

package/dist/core/resource-loader.js

@@ -13,78 +13,99 @@ import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills } from "./skills.js";
 function resolvePromptInput(input, description) {
-    if (!input) {
+    if (!input)
         return undefined;
+    if (!existsSync(input))
+        return input;
+    try {
+        return readFileSync(input, "utf-8");
     }
-    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;
-        }
+    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", "CLAUDE.md"];
-    for (const filename of candidates) {
+    for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
         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}`));
-            }
+        if (!existsSync(filePath)) {
+            continue;
+        }
+        try {
+            return { path: filePath, content: readFileSync(filePath, "utf-8") };
+        }
+        catch (error) {
+            console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
         }
     }
     return null;
 }
 function loadProjectContextFiles(options = {}) {
-    const resolvedCwd = options.cwd ?? process.cwd();
-    const resolvedAgentDir = options.agentDir ?? getAgentDir();
+    const cwd = options.cwd ?? process.cwd();
+    const agentDir = options.agentDir ?? getAgentDir();
     const contextFiles = [];
-    const seenPaths = new Set();
-    const globalContext = loadContextFileFromDir(resolvedAgentDir);
+    const seen = new Set();
+    const globalContext = loadContextFileFromDir(agentDir);
     if (globalContext) {
         contextFiles.push(globalContext);
-        seenPaths.add(globalContext.path);
+        seen.add(globalContext.path);
     }
-    const ancestorContextFiles = [];
-    let currentDir = resolvedCwd;
+    const ancestorFiles = [];
+    let currentDir = cwd;
     const root = resolve("/");
     while (true) {
-        const contextFile = loadContextFileFromDir(currentDir);
-        if (contextFile && !seenPaths.has(contextFile.path)) {
-            ancestorContextFiles.unshift(contextFile);
-            seenPaths.add(contextFile.path);
+        const candidate = loadContextFileFromDir(currentDir);
+        if (candidate && !seen.has(candidate.path)) {
+            ancestorFiles.unshift(candidate);
+            seen.add(candidate.path);
         }
-        if (currentDir === root)
+        if (currentDir === root) {
             break;
-        const parentDir = resolve(currentDir, "..");
-        if (parentDir === currentDir)
+        }
+        const parent = resolve(currentDir, "..");
+        if (parent === currentDir) {
             break;
-        currentDir = parentDir;
+        }
+        currentDir = parent;
     }
-    contextFiles.push(...ancestorContextFiles);
+    contextFiles.push(...ancestorFiles);
     return contextFiles;
 }
+function isUnderPath(target, root) {
+    const normalizedRoot = resolve(root);
+    if (target === normalizedRoot)
+        return true;
+    const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+    return target.startsWith(prefix);
+}
+function resolveResourcePath(cwd, targetPath) {
+    let expanded = targetPath.trim();
+    if (expanded === "~")
+        expanded = homedir();
+    else if (expanded.startsWith("~/"))
+        expanded = join(homedir(), expanded.slice(2));
+    else if (expanded.startsWith("~"))
+        expanded = join(homedir(), expanded.slice(1));
+    return resolve(cwd, expanded);
+}
 export class DefaultResourceLoader {
     constructor(options) {
+        this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+        this.hooksResult = { hooks: [], errors: [] };
+        this.skills = [];
+        this.skillDiagnostics = [];
+        this.prompts = [];
+        this.promptDiagnostics = [];
+        this.themes = [];
+        this.themeDiagnostics = [];
+        this.agentsFiles = [];
+        this.appendSystemPrompt = [];
+        this.pathMetadata = new Map();
         this.cwd = options.cwd ?? process.cwd();
         this.agentDir = options.agentDir ?? getAgentDir();
         this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir);
         this.eventBus = options.eventBus ?? createEventBus();
-        this.packageManager = new DefaultPackageManager({
-            cwd: this.cwd,
-            agentDir: this.agentDir,
-            settingsManager: this.settingsManager,
-        });
+        this.packageManager = new DefaultPackageManager({ cwd: this.cwd, agentDir: this.agentDir, settingsManager: this.settingsManager });
         this.additionalExtensionPaths = options.additionalExtensionPaths ?? [];
         this.additionalHookPaths = options.additionalHookPaths ?? [];
         this.additionalSkillPaths = options.additionalSkillPaths ?? [];
@@ -106,79 +127,37 @@ export class DefaultResourceLoader {
         this.agentsFilesOverride = options.agentsFilesOverride;
         this.systemPromptOverride = options.systemPromptOverride;
         this.appendSystemPromptOverride = options.appendSystemPromptOverride;
-        this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
-        this.hooksResult = { hooks: [], errors: [] };
-        this.skills = [];
-        this.skillDiagnostics = [];
-        this.prompts = [];
-        this.promptDiagnostics = [];
-        this.themes = [];
-        this.themeDiagnostics = [];
-        this.agentsFiles = [];
-        this.appendSystemPrompt = [];
-        this.pathMetadata = new Map();
-    }
-    getExtensions() {
-        return this.extensionsResult;
-    }
-    getHooks() {
-        return this.hooksResult;
-    }
-    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;
-    }
-    getPathMetadata() {
-        return this.pathMetadata;
     }
-    async reload() {
-        const resolvedPaths = await this.packageManager.resolve();
-        const hookSources = this.splitHookSources(this.additionalHookPaths);
-        const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
-            temporary: true,
+    getExtensions() { return this.extensionsResult; }
+    getHooks() { return this.hooksResult; }
+    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; }
+    getPathMetadata() { return this.pathMetadata; }
+    captureEnabledResources(resources, metadata) {
+        for (const resource of resources) {
+            if (!metadata.has(resource.path)) {
+                metadata.set(resource.path, resource.metadata);
+            }
+        }
+        return resources.filter((resource) => resource.enabled).map((resource) => resource.path);
+    }
+    captureEnabledSkillResources(resources, metadata) {
+        const enabledResources = resources.filter((resource) => {
+            if (!metadata.has(resource.path)) {
+                metadata.set(resource.path, resource.metadata);
+            }
+            return resource.enabled;
         });
-        const cliHookPaths = await this.packageManager.resolveExtensionSources(hookSources.packageSources, {
-            temporary: true,
-        });
-        const directHookPaths = this.expandHookPaths(hookSources.directPaths);
-        // Helper to extract enabled paths and store metadata
-        const getEnabledResources = (resources) => {
-            for (const r of resources) {
-                if (!this.pathMetadata.has(r.path)) {
-                    this.pathMetadata.set(r.path, r.metadata);
-                }
-            }
-            return resources.filter((r) => r.enabled);
-        };
-        const getEnabledPaths = (resources) => getEnabledResources(resources).map((r) => r.path);
-        // Store metadata and get enabled paths
-        this.pathMetadata = new Map();
-        const enabledExtensions = getEnabledPaths(resolvedPaths.extensions);
-        const enabledHooks = getEnabledPaths(resolvedPaths.hooks);
-        const enabledSkillResources = getEnabledResources(resolvedPaths.skills);
-        const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
-        const enabledThemes = getEnabledPaths(resolvedPaths.themes);
-        const mapSkillPath = (resource) => {
+        return enabledResources.map((resource) => {
             if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
                 return resource.path;
             }
             try {
-                const stats = statSync(resource.path);
-                if (!stats.isDirectory()) {
+                if (!statSync(resource.path).isDirectory()) {
                     return resource.path;
                 }
             }
@@ -186,149 +165,17 @@ export class DefaultResourceLoader {
                 return resource.path;
             }
             const skillFile = join(resource.path, "SKILL.md");
-            if (existsSync(skillFile)) {
-                if (!this.pathMetadata.has(skillFile)) {
-                    this.pathMetadata.set(skillFile, resource.metadata);
-                }
-                return skillFile;
-            }
-            return resource.path;
-        };
-        const enabledSkills = enabledSkillResources.map(mapSkillPath);
-        // Add CLI paths metadata
-        for (const r of cliExtensionPaths.extensions) {
-            if (!this.pathMetadata.has(r.path)) {
-                this.pathMetadata.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
-            }
-        }
-        for (const r of cliHookPaths.hooks) {
-            if (!this.pathMetadata.has(r.path)) {
-                this.pathMetadata.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
-            }
-        }
-        for (const hookPath of directHookPaths) {
-            if (!this.pathMetadata.has(hookPath)) {
-                this.pathMetadata.set(hookPath, { source: "cli", scope: "temporary", origin: "top-level" });
-            }
-        }
-        for (const r of cliExtensionPaths.skills) {
-            if (!this.pathMetadata.has(r.path)) {
-                this.pathMetadata.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
-            }
-        }
-        const cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions);
-        const cliEnabledHooks = getEnabledPaths(cliHookPaths.hooks);
-        const cliEnabledSkills = getEnabledPaths(cliExtensionPaths.skills);
-        const cliEnabledPrompts = getEnabledPaths(cliExtensionPaths.prompts);
-        const cliEnabledThemes = getEnabledPaths(cliExtensionPaths.themes);
-        const extensionPaths = this.noExtensions
-            ? cliEnabledExtensions
-            : this.mergePaths(enabledExtensions, cliEnabledExtensions);
-        const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus);
-        const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
-        extensionsResult.extensions.push(...inlineExtensions.extensions);
-        extensionsResult.errors.push(...inlineExtensions.errors);
-        // Detect extension conflicts (tools, commands, flags with same names from different extensions)
-        const conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
-        if (conflicts.length > 0) {
-            const conflictingPaths = new Set(conflicts.map((c) => c.path));
-            extensionsResult.extensions = extensionsResult.extensions.filter((ext) => !conflictingPaths.has(ext.path));
-            for (const conflict of conflicts) {
-                extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
-            }
-        }
-        this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
-        const hookPaths = this.noHooks
-            ? this.mergePaths(cliEnabledHooks, directHookPaths)
-            : this.mergePaths([...enabledHooks, ...cliEnabledHooks], directHookPaths);
-        const hooksResult = hookPaths.length > 0 ? await loadHooks(hookPaths, this.cwd, this.agentDir, this.eventBus) : { hooks: [], errors: [] };
-        this.hooksResult = this.hooksOverride ? this.hooksOverride(hooksResult) : hooksResult;
-        const skillPaths = this.noSkills
-            ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths)
-            : this.mergePaths([...enabledSkills, ...cliEnabledSkills], this.additionalSkillPaths);
-        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;
-        this.skillDiagnostics = resolvedSkills.diagnostics;
-        for (const skill of this.skills) {
-            this.addDefaultMetadataForPath(skill.filePath);
-        }
-        const promptPaths = this.noPromptTemplates
-            ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths)
-            : this.mergePaths([...enabledPrompts, ...cliEnabledPrompts], this.additionalPromptTemplatePaths);
-        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;
-        this.promptDiagnostics = resolvedPrompts.diagnostics;
-        for (const prompt of this.prompts) {
-            this.addDefaultMetadataForPath(prompt.filePath);
-        }
-        const themePaths = this.noThemes
-            ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths)
-            : this.mergePaths([...enabledThemes, ...cliEnabledThemes], this.additionalThemePaths);
-        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;
-        this.themeDiagnostics = resolvedThemes.diagnostics;
-        for (const theme of this.themes) {
-            if (theme.sourcePath) {
-                this.addDefaultMetadataForPath(theme.sourcePath);
+            if (existsSync(skillFile) && !metadata.has(skillFile)) {
+                metadata.set(skillFile, resource.metadata);
             }
-        }
-        for (const extension of this.extensionsResult.extensions) {
-            this.addDefaultMetadataForPath(extension.path);
-        }
-        for (const hook of this.hooksResult.hooks) {
-            this.addDefaultMetadataForPath(hook.path);
-        }
-        const agentsFiles = { agentsFiles: 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");
-        this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
-        const appendSource = this.appendSystemPromptSource ?? this.discoverAppendSystemPromptFile();
-        const resolvedAppend = resolvePromptInput(appendSource, "append system prompt");
-        const baseAppend = resolvedAppend ? [resolvedAppend] : [];
-        this.appendSystemPrompt = this.appendSystemPromptOverride
-            ? this.appendSystemPromptOverride(baseAppend)
-            : baseAppend;
+            return existsSync(skillFile) ? skillFile : resource.path;
+        });
     }
     splitHookSources(paths) {
         const packageSources = [];
         const directPaths = [];
         for (const entry of paths) {
-            if (this.isPackageSource(entry)) {
+            if (entry.startsWith("npm:") || entry.startsWith("git:") || looksLikeGitUrl(entry.trim())) {
                 packageSources.push(entry);
             }
             else {
@@ -337,36 +184,26 @@ export class DefaultResourceLoader {
         }
         return { packageSources, directPaths };
     }
-    isPackageSource(path) {
-        const trimmed = path.trim();
-        return trimmed.startsWith("npm:") || trimmed.startsWith("git:") || looksLikeGitUrl(trimmed);
-    }
     expandHookPaths(paths) {
-        const expanded = [];
-        for (const pathToHook of paths) {
-            const resolved = this.resolveResourcePath(pathToHook);
+        return paths.flatMap((hookPath) => {
+            const resolved = resolveResourcePath(this.cwd, hookPath);
             try {
-                const stats = statSync(resolved);
-                if (stats.isDirectory()) {
+                if (statSync(resolved).isDirectory()) {
                     const discovered = discoverHooksInDir(resolved);
-                    if (discovered.length > 0) {
-                        expanded.push(...discovered);
-                        continue;
-                    }
+                    return discovered.length > 0 ? discovered : [resolved];
                 }
             }
             catch {
-                // Keep the original path so we can report a load error later
+                return [resolved];
             }
-            expanded.push(resolved);
-        }
-        return expanded;
+            return [resolved];
+        });
     }
     mergePaths(primary, additional) {
         const merged = [];
         const seen = new Set();
-        for (const p of [...primary, ...additional]) {
-            const resolved = this.resolveResourcePath(p);
+        for (const targetPath of [...primary, ...additional]) {
+            const resolved = resolveResourcePath(this.cwd, targetPath);
             if (seen.has(resolved))
                 continue;
             seen.add(resolved);
@@ -374,108 +211,55 @@ export class DefaultResourceLoader {
         }
         return merged;
     }
-    resolveResourcePath(p) {
-        const trimmed = p.trim();
-        let expanded = trimmed;
-        if (trimmed === "~") {
-            expanded = homedir();
-        }
-        else if (trimmed.startsWith("~/")) {
-            expanded = join(homedir(), trimmed.slice(2));
-        }
-        else if (trimmed.startsWith("~")) {
-            expanded = join(homedir(), trimmed.slice(1));
-        }
-        return resolve(this.cwd, expanded);
-    }
-    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 = resolve(this.cwd, p);
-            if (!existsSync(resolved)) {
-                diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
-                continue;
-            }
+    async loadInlineExtensions(runtime) {
+        const extensions = [];
+        const errors = [];
+        for (const [index, factory] of this.extensionFactories.entries()) {
+            const path = `<inline:${index + 1}>`;
             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 });
-                }
+                extensions.push(await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, path));
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : "failed to read theme path";
-                diagnostics.push({ type: "warning", message, path: resolved });
+                errors.push({ path, error: error instanceof Error ? error.message : "failed to load extension" });
             }
         }
-        return { themes, diagnostics };
+        return { extensions, errors };
     }
-    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;
+    detectExtensionConflicts(extensions) {
+        const conflicts = [];
+        const toolOwners = new Map();
+        const commandOwners = new Map();
+        const flagOwners = new Map();
+        for (const extension of extensions) {
+            for (const toolName of extension.tools.keys()) {
+                const owner = toolOwners.get(toolName);
+                if (owner && owner !== extension.path) {
+                    conflicts.push({ path: extension.path, message: `Tool "${toolName}" conflicts with ${owner}` });
                 }
-                if (!entry.name.endsWith(".json")) {
-                    continue;
+                else {
+                    toolOwners.set(toolName, extension.path);
                 }
-                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 });
-        }
-    }
-    async loadExtensionFactories(runtime) {
-        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);
-                extensions.push(extension);
+            for (const commandName of extension.commands.keys()) {
+                const owner = commandOwners.get(commandName);
+                if (owner && owner !== extension.path) {
+                    conflicts.push({ path: extension.path, message: `Command "/${commandName}" conflicts with ${owner}` });
+                }
+                else {
+                    commandOwners.set(commandName, extension.path);
+                }
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "failed to load extension";
-                errors.push({ path: extensionPath, error: message });
+            for (const flagName of extension.flags.keys()) {
+                const owner = flagOwners.get(flagName);
+                if (owner && owner !== extension.path) {
+                    conflicts.push({ path: extension.path, message: `Flag "--${flagName}" conflicts with ${owner}` });
+                }
+                else {
+                    flagOwners.set(flagName, extension.path);
+                }
             }
         }
-        return { extensions, errors };
+        return conflicts;
     }
     dedupePrompts(prompts) {
         const seen = new Map();
@@ -487,158 +271,260 @@ export class DefaultResourceLoader {
                     type: "collision",
                     message: `name "/${prompt.name}" collision`,
                     path: prompt.filePath,
-                    collision: {
-                        resourceType: "prompt",
-                        name: prompt.name,
-                        winnerPath: existing.filePath,
-                        loserPath: prompt.filePath,
-                    },
+                    collision: { resourceType: "prompt", name: prompt.name, winnerPath: existing.filePath, loserPath: prompt.filePath },
                 });
+                continue;
             }
-            else {
-                seen.set(prompt.name, prompt);
-            }
+            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";
+        for (const theme of themes) {
+            const name = theme.name ?? "unnamed";
             const existing = seen.get(name);
             if (existing) {
                 diagnostics.push({
                     type: "collision",
                     message: `name "${name}" collision`,
-                    path: t.sourcePath,
+                    path: theme.sourcePath,
                     collision: {
                         resourceType: "theme",
                         name,
                         winnerPath: existing.sourcePath ?? "<builtin>",
-                        loserPath: t.sourcePath ?? "<builtin>",
+                        loserPath: theme.sourcePath ?? "<builtin>",
                     },
                 });
+                continue;
             }
-            else {
-                seen.set(name, t);
-            }
+            seen.set(name, theme);
         }
         return { themes: Array.from(seen.values()), diagnostics };
     }
-    discoverSystemPromptFile() {
-        const projectPath = join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
-        if (existsSync(projectPath)) {
-            return projectPath;
+    loadThemesFromDir(dir, themes, diagnostics) {
+        if (!existsSync(dir))
+            return;
+        try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                let isFile = entry.isFile();
+                if (entry.isSymbolicLink()) {
+                    try {
+                        isFile = statSync(join(dir, entry.name)).isFile();
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!isFile || !entry.name.endsWith(".json"))
+                    continue;
+                this.loadThemeFromFile(join(dir, entry.name), themes, diagnostics);
+            }
         }
-        const globalPath = join(this.agentDir, "SYSTEM.md");
-        if (existsSync(globalPath)) {
-            return globalPath;
+        catch (error) {
+            diagnostics.push({ type: "warning", message: error instanceof Error ? error.message : "failed to read theme directory", path: dir });
+        }
+    }
+    loadThemeFromFile(filePath, themes, diagnostics) {
+        try {
+            themes.push(loadThemeFromPath(filePath));
+        }
+        catch (error) {
+            diagnostics.push({ type: "warning", message: error instanceof Error ? error.message : "failed to load theme", path: filePath });
+        }
+    }
+    loadThemeResources(paths) {
+        const themes = [];
+        const diagnostics = [];
+        for (const themePath of paths) {
+            const resolvedPath = resolve(this.cwd, themePath);
+            if (!existsSync(resolvedPath)) {
+                diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolvedPath });
+                continue;
+            }
+            try {
+                const stats = statSync(resolvedPath);
+                if (stats.isDirectory())
+                    this.loadThemesFromDir(resolvedPath, themes, diagnostics);
+                else if (stats.isFile() && resolvedPath.endsWith(".json"))
+                    this.loadThemeFromFile(resolvedPath, themes, diagnostics);
+                else
+                    diagnostics.push({ type: "warning", message: "theme path is not a json file", path: resolvedPath });
+            }
+            catch (error) {
+                diagnostics.push({ type: "warning", message: error instanceof Error ? error.message : "failed to read theme path", path: resolvedPath });
+            }
+        }
+        return { themes, diagnostics };
+    }
+    discoverSystemPromptFile() {
+        for (const filePath of [join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md"), join(this.agentDir, "SYSTEM.md")]) {
+            if (existsSync(filePath))
+                return filePath;
         }
         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;
+        for (const filePath of [join(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md"), join(this.agentDir, "APPEND_SYSTEM.md")]) {
+            if (existsSync(filePath))
+                return filePath;
         }
         return undefined;
     }
-    addDefaultMetadataForPath(filePath) {
-        if (!filePath || filePath.startsWith("<")) {
+    addDefaultMetadataForPath(filePath, metadata) {
+        if (!filePath || filePath.startsWith("<"))
             return;
-        }
-        const normalizedPath = resolve(filePath);
-        if (this.pathMetadata.has(normalizedPath) || this.pathMetadata.has(filePath)) {
+        const normalized = resolve(filePath);
+        if (metadata.has(normalized) || metadata.has(filePath))
+            return;
+        const userRoots = ["skills", "prompts", "themes", "extensions", "hooks"].map((name) => join(this.agentDir, name));
+        const projectRoots = ["skills", "prompts", "themes", "extensions", "hooks"].map((name) => join(this.cwd, CONFIG_DIR_NAME, name));
+        if (userRoots.some((root) => isUnderPath(normalized, root))) {
+            metadata.set(normalized, { source: "local", scope: "user", origin: "top-level" });
             return;
         }
-        const agentRoots = [
-            join(this.agentDir, "skills"),
-            join(this.agentDir, "prompts"),
-            join(this.agentDir, "themes"),
-            join(this.agentDir, "extensions"),
-            join(this.agentDir, "hooks"),
-        ];
-        const projectRoots = [
-            join(this.cwd, CONFIG_DIR_NAME, "skills"),
-            join(this.cwd, CONFIG_DIR_NAME, "prompts"),
-            join(this.cwd, CONFIG_DIR_NAME, "themes"),
-            join(this.cwd, CONFIG_DIR_NAME, "extensions"),
-            join(this.cwd, CONFIG_DIR_NAME, "hooks"),
-        ];
-        for (const root of agentRoots) {
-            if (this.isUnderPath(normalizedPath, root)) {
-                this.pathMetadata.set(normalizedPath, { source: "local", scope: "user", origin: "top-level" });
-                return;
-            }
+        if (projectRoots.some((root) => isUnderPath(normalized, root))) {
+            metadata.set(normalized, { source: "local", scope: "project", origin: "top-level" });
         }
-        for (const root of projectRoots) {
-            if (this.isUnderPath(normalizedPath, root)) {
-                this.pathMetadata.set(normalizedPath, { source: "local", scope: "project", origin: "top-level" });
-                return;
+    }
+    async loadExtensionResources(extensionPaths) {
+        const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus);
+        const inlineExtensions = await this.loadInlineExtensions(extensionsResult.runtime);
+        extensionsResult.extensions.push(...inlineExtensions.extensions);
+        extensionsResult.errors.push(...inlineExtensions.errors);
+        const conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
+        if (conflicts.length > 0) {
+            const conflictingPaths = new Set(conflicts.map((conflict) => conflict.path));
+            extensionsResult.extensions = extensionsResult.extensions.filter((ext) => !conflictingPaths.has(ext.path));
+            for (const conflict of conflicts) {
+                extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
             }
         }
+        return this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
+    }
+    async loadHookResources(hookPaths) {
+        const base = hookPaths.length > 0 ? await loadHooks(hookPaths, this.cwd, this.agentDir, this.eventBus) : { hooks: [], errors: [] };
+        return this.hooksOverride ? this.hooksOverride(base) : base;
+    }
+    loadSkillResources(skillPaths) {
+        const base = this.noSkills && skillPaths.length === 0
+            ? { skills: [], diagnostics: [] }
+            : loadSkills({ cwd: this.cwd, agentDir: this.agentDir, skillPaths, includeDefaults: false });
+        return this.skillsOverride ? this.skillsOverride(base) : base;
+    }
+    loadPromptResources(promptPaths) {
+        const base = this.noPromptTemplates && promptPaths.length === 0
+            ? { prompts: [], diagnostics: [] }
+            : (() => {
+                const allPrompts = loadPromptTemplates({ cwd: this.cwd, agentDir: this.agentDir, promptPaths, includeDefaults: false });
+                return this.dedupePrompts(allPrompts);
+            })();
+        return this.promptsOverride ? this.promptsOverride(base) : base;
+    }
+    loadThemePhase(themePaths) {
+        const base = this.noThemes && themePaths.length === 0
+            ? { themes: [], diagnostics: [] }
+            : (() => {
+                const loaded = this.loadThemeResources(themePaths);
+                const deduped = this.dedupeThemes(loaded.themes);
+                return { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
+            })();
+        return this.themesOverride ? this.themesOverride(base) : base;
+    }
+    loadAgentsPhase() {
+        const base = { agentsFiles: loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }) };
+        return this.agentsFilesOverride ? this.agentsFilesOverride(base).agentsFiles : base.agentsFiles;
+    }
+    resolvePromptOverrides() {
+        const baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
+        const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
+        const appendSource = this.appendSystemPromptSource ?? this.discoverAppendSystemPromptFile();
+        const resolvedAppend = resolvePromptInput(appendSource, "append system prompt");
+        const baseAppend = resolvedAppend ? [resolvedAppend] : [];
+        return {
+            systemPrompt,
+            appendSystemPrompt: this.appendSystemPromptOverride ? this.appendSystemPromptOverride(baseAppend) : baseAppend,
+        };
     }
-    isUnderPath(target, root) {
-        const normalizedRoot = resolve(root);
-        if (target === normalizedRoot) {
-            return true;
-        }
-        const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
-        return target.startsWith(prefix);
+    composeResourceSnapshot(snapshot) {
+        this.extensionsResult = snapshot.extensionsResult;
+        this.hooksResult = snapshot.hooksResult;
+        this.skills = snapshot.skills;
+        this.skillDiagnostics = snapshot.skillDiagnostics;
+        this.prompts = snapshot.prompts;
+        this.promptDiagnostics = snapshot.promptDiagnostics;
+        this.themes = snapshot.themes;
+        this.themeDiagnostics = snapshot.themeDiagnostics;
+        this.agentsFiles = snapshot.agentsFiles;
+        this.systemPrompt = snapshot.systemPrompt;
+        this.appendSystemPrompt = snapshot.appendSystemPrompt;
+        this.pathMetadata = snapshot.pathMetadata;
     }
-    detectExtensionConflicts(extensions) {
-        const conflicts = [];
-        // Track which extension registered each tool, command, and flag
-        const toolOwners = new Map();
-        const commandOwners = 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 commands
-            for (const commandName of ext.commands.keys()) {
-                const existingOwner = commandOwners.get(commandName);
-                if (existingOwner && existingOwner !== ext.path) {
-                    conflicts.push({
-                        path: ext.path,
-                        message: `Command "/${commandName}" conflicts with ${existingOwner}`,
-                    });
-                }
-                else {
-                    commandOwners.set(commandName, ext.path);
-                }
-            }
-            // Check flags
-            for (const flagName of ext.flags.keys()) {
-                const existingOwner = flagOwners.get(flagName);
-                if (existingOwner && existingOwner !== ext.path) {
-                    conflicts.push({
-                        path: ext.path,
-                        message: `Flag "--${flagName}" conflicts with ${existingOwner}`,
-                    });
-                }
-                else {
-                    flagOwners.set(flagName, ext.path);
-                }
+    async reload() {
+        const packageResources = await this.packageManager.resolve();
+        const hookSources = this.splitHookSources(this.additionalHookPaths);
+        const cliResources = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, { temporary: true });
+        const cliHookResources = await this.packageManager.resolveExtensionSources(hookSources.packageSources, { temporary: true });
+        const directHookPaths = this.expandHookPaths(hookSources.directPaths);
+        const metadata = new Map();
+        const enabledExtensions = this.captureEnabledResources(packageResources.extensions, metadata);
+        const enabledHooks = this.captureEnabledResources(packageResources.hooks, metadata);
+        const enabledSkills = this.captureEnabledSkillResources(packageResources.skills, metadata);
+        const enabledPrompts = this.captureEnabledResources(packageResources.prompts, metadata);
+        const enabledThemes = this.captureEnabledResources(packageResources.themes, metadata);
+        for (const resource of [...cliResources.extensions, ...cliHookResources.hooks, ...cliResources.skills, ...cliResources.prompts, ...cliResources.themes]) {
+            if (!metadata.has(resource.path)) {
+                metadata.set(resource.path, { source: "cli", scope: "temporary", origin: "top-level" });
             }
         }
-        return conflicts;
+        for (const hookPath of directHookPaths) {
+            if (!metadata.has(hookPath)) {
+                metadata.set(hookPath, { source: "cli", scope: "temporary", origin: "top-level" });
+            }
+        }
+        const cliEnabledExtensions = cliResources.extensions.filter((item) => item.enabled).map((item) => item.path);
+        const cliEnabledHooks = cliHookResources.hooks.filter((item) => item.enabled).map((item) => item.path);
+        const cliEnabledSkills = cliResources.skills.filter((item) => item.enabled).map((item) => item.path);
+        const cliEnabledPrompts = cliResources.prompts.filter((item) => item.enabled).map((item) => item.path);
+        const cliEnabledThemes = cliResources.themes.filter((item) => item.enabled).map((item) => item.path);
+        const extensionPaths = this.noExtensions ? cliEnabledExtensions : this.mergePaths(enabledExtensions, cliEnabledExtensions);
+        const hookPaths = this.noHooks ? this.mergePaths(cliEnabledHooks, directHookPaths) : this.mergePaths([...enabledHooks, ...cliEnabledHooks], directHookPaths);
+        const skillPaths = this.noSkills ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths) : this.mergePaths([...enabledSkills, ...cliEnabledSkills], this.additionalSkillPaths);
+        const promptPaths = this.noPromptTemplates ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths) : this.mergePaths([...enabledPrompts, ...cliEnabledPrompts], this.additionalPromptTemplatePaths);
+        const themePaths = this.noThemes ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths) : this.mergePaths([...enabledThemes, ...cliEnabledThemes], this.additionalThemePaths);
+        const extensionsResult = await this.loadExtensionResources(extensionPaths);
+        const hooksResult = await this.loadHookResources(hookPaths);
+        const skillsResult = this.loadSkillResources(skillPaths);
+        const promptsResult = this.loadPromptResources(promptPaths);
+        const themesResult = this.loadThemePhase(themePaths);
+        const agentsFiles = this.loadAgentsPhase();
+        const promptOverrides = this.resolvePromptOverrides();
+        for (const skill of skillsResult.skills)
+            this.addDefaultMetadataForPath(skill.filePath, metadata);
+        for (const prompt of promptsResult.prompts)
+            this.addDefaultMetadataForPath(prompt.filePath, metadata);
+        for (const theme of themesResult.themes)
+            if (theme.sourcePath)
+                this.addDefaultMetadataForPath(theme.sourcePath, metadata);
+        for (const extension of extensionsResult.extensions)
+            this.addDefaultMetadataForPath(extension.path, metadata);
+        for (const hook of hooksResult.hooks)
+            this.addDefaultMetadataForPath(hook.path, metadata);
+        this.composeResourceSnapshot({
+            extensionsResult,
+            hooksResult,
+            skills: skillsResult.skills,
+            skillDiagnostics: skillsResult.diagnostics,
+            prompts: promptsResult.prompts,
+            promptDiagnostics: promptsResult.diagnostics,
+            themes: themesResult.themes,
+            themeDiagnostics: themesResult.diagnostics,
+            agentsFiles,
+            systemPrompt: promptOverrides.systemPrompt,
+            appendSystemPrompt: promptOverrides.appendSystemPrompt,
+            pathMetadata: metadata,
+        });
     }
 }
 //# sourceMappingURL=resource-loader.js.map