@elliotding/ai-agent-mcp 0.1.0

package/dist/monitoring/health.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthChecker = void 0;
+class HealthChecker {
+    cacheManager = null;
+    constructor(cacheManager) {
+        this.cacheManager = cacheManager || null;
+    }
+    /**
+     * Check HTTP Server health
+     */
+    checkHttpServer() {
+        // HTTP server is up if this code is running
+        return 'up';
+    }
+    /**
+     * Check Redis connection health
+     */
+    async checkRedis() {
+        if (!this.cacheManager) {
+            return { status: 'not_configured' };
+        }
+        try {
+            // Try to check Redis connection via cache manager
+            const redisCache = this.cacheManager.l2Cache;
+            if (!redisCache) {
+                return { status: 'not_configured' };
+            }
+            // Try a simple Redis operation (check client status)
+            const client = redisCache.client;
+            if (!client || !client.isReady) {
+                return { status: 'down', error: 'Redis client not ready' };
+            }
+            // Try a ping operation
+            await client.ping();
+            return { status: 'up' };
+        }
+        catch (error) {
+            return {
+                status: 'down',
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Check Cache health
+     */
+    checkCache() {
+        if (!this.cacheManager) {
+            return { status: 'down', error: 'Cache manager not initialized' };
+        }
+        try {
+            // Check if cache manager is functional
+            const stats = this.cacheManager.getStats();
+            // Cache is healthy if stats are available
+            if (stats && typeof stats.hitRate === 'number') {
+                // Check if hit rate is reasonable (> 0 means cache is working)
+                if (stats.hitRate >= 0) {
+                    return { status: 'healthy' };
+                }
+                return { status: 'degraded', error: 'Low cache hit rate' };
+            }
+            return { status: 'degraded', error: 'Cache stats unavailable' };
+        }
+        catch (error) {
+            return {
+                status: 'down',
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Perform comprehensive health check
+     */
+    async check() {
+        const httpStatus = this.checkHttpServer();
+        const redisResult = await this.checkRedis();
+        const cacheResult = this.checkCache();
+        const allHealthy = httpStatus === 'up' &&
+            (redisResult.status === 'up' || redisResult.status === 'not_configured') &&
+            cacheResult.status === 'healthy';
+        const health = {
+            status: allHealthy ? 'healthy' : 'unhealthy',
+            timestamp: new Date().toISOString(),
+            services: {
+                http: httpStatus,
+                redis: redisResult.status,
+                cache: cacheResult.status
+            }
+        };
+        // Add error details if any
+        if (redisResult.error || cacheResult.error) {
+            health.details = {};
+            if (redisResult.error) {
+                health.details.redisError = redisResult.error;
+            }
+            if (cacheResult.error) {
+                health.details.cacheError = cacheResult.error;
+            }
+        }
+        return health;
+    }
+}
+exports.HealthChecker = HealthChecker;
+//# sourceMappingURL=health.js.map

package/dist/monitoring/health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.js","sourceRoot":"","sources":["../../src/monitoring/health.ts"],"names":[],"mappings":"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"}

package/dist/resources/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resources Module Exports
+ */
+export { ResourceLoader, resourceLoader } from './loader';
+export type { AIResourcesConfig, ResourceMetadata, ResourceType, ResourceSource, ResourceConflict, LoaderStats, } from '../types/resources';
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1D,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,WAAW,GACZ,MAAM,oBAAoB,CAAC"}

package/dist/resources/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Resources Module Exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceLoader = exports.ResourceLoader = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "ResourceLoader", { enumerable: true, get: function () { return loader_1.ResourceLoader; } });
+Object.defineProperty(exports, "resourceLoader", { enumerable: true, get: function () { return loader_1.resourceLoader; } });
+//# sourceMappingURL=index.js.map

package/dist/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,mCAA0D;AAAjD,wGAAA,cAAc,OAAA;AAAE,wGAAA,cAAc,OAAA"}

package/dist/resources/loader.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Resource Loader Module
+ * Manages multi-source AI resource loading and indexing
+ *
+ * Implements AI Resources Multi-Source Architecture as defined in:
+ * @see Docs/AI-Resources-Multi-Source-Architecture.md
+ * @see AGENTS.md (AI Resources 开发约束)
+ */
+import type { ResourceMetadata, ResourceType, ResourceConflict, LoaderStats } from '../types/resources';
+/**
+ * Resource Loader
+ *
+ * Key responsibilities:
+ * 1. Load and validate ai-resources-config.json
+ * 2. Scan resources from multiple sources
+ * 3. Build resource index with priority
+ * 4. Resolve resource name conflicts
+ * 5. Provide unified resource query interface
+ */
+export declare class ResourceLoader {
+    private config;
+    private resourceIndex;
+    private conflicts;
+    private stats;
+    private loaded;
+    private cacheEnabled;
+    private cacheTTL;
+    private lastLoadTime;
+    /**
+     * Load AI Resources configuration file
+     */
+    loadConfig(configPath?: string): Promise<void>;
+    /**
+     * Validate configuration structure and constraints
+     */
+    private validateConfig;
+    /**
+     * Get default configuration (fallback)
+     */
+    private getDefaultConfig;
+    /**
+     * Scan and index resources from all sources
+     */
+    scanResources(): Promise<void>;
+    /**
+     * Scan resources from a single source
+     */
+    private scanSource;
+    /**
+     * Scan resources of a specific type from a directory
+     */
+    private scanResourceType;
+    /**
+     * Index a single resource with conflict detection
+     */
+    private indexResource;
+    /**
+     * Get all resources by type
+     */
+    getResourcesByType(type: ResourceType): ResourceMetadata[];
+    /**
+     * Get resource by ID (type:name)
+     */
+    getResourceById(id: string): ResourceMetadata | null;
+    /**
+     * Search resources by name
+     */
+    searchResourcesByName(name: string, type?: ResourceType): ResourceMetadata[];
+    /**
+     * Get all detected conflicts
+     */
+    getConflicts(): ResourceConflict[];
+    /**
+     * Get loader statistics
+     */
+    getStats(): LoaderStats | null;
+    /**
+     * Refresh resource index (clear cache and rescan)
+     */
+    refresh(): Promise<void>;
+    /**
+     * Ensure resources are loaded
+     */
+    private ensureLoaded;
+}
+export declare const resourceLoader: ResourceLoader;
+//# sourceMappingURL=loader.d.ts.map

package/dist/resources/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/resources/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAEV,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,MAAM,CAAkB;IAGhC,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,YAAY,CAAa;IAEjC;;OAEG;IACG,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDpD;;OAEG;IACH,OAAO,CAAC,cAAc;IAsEtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA2BxB;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAyEpC;;OAEG;YACW,UAAU;IAqCxB;;OAEG;YACW,gBAAgB;IAyC9B;;OAEG;YACW,aAAa;IAsF3B;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,EAAE;IAW1D;;OAEG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAKpD;;OAEG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,gBAAgB,EAAE;IAiB5E;;OAEG;IACH,YAAY,IAAI,gBAAgB,EAAE;IAKlC;;OAEG;IACH,QAAQ,IAAI,WAAW,GAAG,IAAI;IAI9B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;OAEG;IACH,OAAO,CAAC,YAAY;CAKrB;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/resources/loader.js

@@ -0,0 +1,452 @@
+"use strict";
+/**
+ * Resource Loader Module
+ * Manages multi-source AI resource loading and indexing
+ *
+ * Implements AI Resources Multi-Source Architecture as defined in:
+ * @see Docs/AI-Resources-Multi-Source-Architecture.md
+ * @see AGENTS.md (AI Resources 开发约束)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceLoader = exports.ResourceLoader = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+/**
+ * Resource Loader
+ *
+ * Key responsibilities:
+ * 1. Load and validate ai-resources-config.json
+ * 2. Scan resources from multiple sources
+ * 3. Build resource index with priority
+ * 4. Resolve resource name conflicts
+ * 5. Provide unified resource query interface
+ */
+class ResourceLoader {
+    config = null;
+    resourceIndex = new Map();
+    conflicts = [];
+    stats = null;
+    loaded = false;
+    // Cache configuration
+    cacheEnabled = false;
+    cacheTTL = 300000; // 5 minutes default
+    lastLoadTime = 0;
+    /**
+     * Load AI Resources configuration file
+     */
+    async loadConfig(configPath) {
+        const startTime = Date.now();
+        try {
+            // Default config path
+            const defaultPath = path.resolve(process.cwd(), 'AI-Resources/ai-resources-config.json');
+            const finalPath = configPath || defaultPath;
+            logger_1.logger.debug({ configPath: finalPath }, 'Loading AI Resources configuration...');
+            // Check if config file exists
+            try {
+                await fs.access(finalPath);
+            }
+            catch {
+                logger_1.logger.warn({ configPath: finalPath }, 'AI Resources config file not found, using default configuration');
+                this.config = this.getDefaultConfig();
+                return;
+            }
+            // Read and parse config file
+            const configContent = await fs.readFile(finalPath, 'utf-8');
+            const parsedConfig = JSON.parse(configContent);
+            // Validate configuration
+            this.validateConfig(parsedConfig);
+            this.config = parsedConfig;
+            this.cacheEnabled = parsedConfig.cache?.enabled ?? true;
+            this.cacheTTL = (parsedConfig.cache?.ttl ?? 300) * 1000; // Convert to ms
+            const duration = Date.now() - startTime;
+            logger_1.logger.info({
+                configPath: finalPath,
+                defaultSource: parsedConfig.default_source.name,
+                extendedSourcesCount: parsedConfig.extended_sources.length,
+                duration,
+            }, 'AI Resources configuration loaded successfully');
+        }
+        catch (error) {
+            logger_1.logger.error({
+                type: 'resource',
+                operation: 'load_config',
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            }, 'Failed to load AI Resources configuration');
+            throw error;
+        }
+    }
+    /**
+     * Validate configuration structure and constraints
+     */
+    validateConfig(config) {
+        // Check version
+        if (config.version !== '1.0') {
+            throw new Error(`Unsupported config version: ${config.version}, expected 1.0`);
+        }
+        // Check default source
+        if (!config.default_source) {
+            throw new Error('Missing required field: default_source');
+        }
+        if (config.default_source.name !== 'csp') {
+            logger_1.logger.warn({ name: config.default_source.name }, 'Default source name is not "csp", this may cause compatibility issues');
+        }
+        if (config.default_source.priority !== 100) {
+            logger_1.logger.warn({ priority: config.default_source.priority }, 'Default source priority is not 100, this may affect conflict resolution');
+        }
+        if (!config.default_source.enabled) {
+            throw new Error('Default source must be enabled');
+        }
+        // Check resource types
+        const expectedTypes = ['commands', 'skills', 'mcp', 'rules'];
+        if (!config.resource_types ||
+            config.resource_types.length !== 4 ||
+            !expectedTypes.every((type) => config.resource_types.includes(type))) {
+            throw new Error(`Invalid resource_types, expected: ${expectedTypes.join(', ')}, got: ${config.resource_types?.join(', ') || 'none'}`);
+        }
+        // Check loading order
+        if (config.loading_order !== 'priority_desc') {
+            logger_1.logger.warn({ loading_order: config.loading_order }, 'Loading order is not "priority_desc", this may affect resource precedence');
+        }
+        // Check conflict resolution
+        if (config.conflict_resolution !== 'highest_priority_wins') {
+            logger_1.logger.warn({ conflict_resolution: config.conflict_resolution }, 'Conflict resolution is not "highest_priority_wins", this may affect behavior');
+        }
+        // Check extended sources priority
+        const defaultPriority = config.default_source.priority;
+        for (const source of config.extended_sources || []) {
+            if (source.priority >= defaultPriority) {
+                throw new Error(`Extended source "${source.name}" has priority ${source.priority} which is >= default source priority ${defaultPriority}. Default source must have highest priority.`);
+            }
+        }
+        logger_1.logger.debug('AI Resources configuration validation passed');
+    }
+    /**
+     * Get default configuration (fallback)
+     */
+    getDefaultConfig() {
+        return {
+            version: '1.0',
+            description: 'Default AI Resources configuration',
+            default_source: {
+                name: 'csp',
+                path: 'csp/ai-resources',
+                enabled: true,
+                priority: 100,
+                resources: {
+                    commands: 'commands',
+                    skills: 'skills',
+                    mcp: 'mcp',
+                    rules: 'rules',
+                },
+            },
+            extended_sources: [],
+            resource_types: ['commands', 'skills', 'mcp', 'rules'],
+            loading_order: 'priority_desc',
+            conflict_resolution: 'highest_priority_wins',
+            cache: {
+                enabled: true,
+                ttl: 300,
+            },
+        };
+    }
+    /**
+     * Scan and index resources from all sources
+     */
+    async scanResources() {
+        if (!this.config) {
+            throw new Error('Configuration not loaded. Call loadConfig() first.');
+        }
+        // Check cache validity
+        if (this.cacheEnabled && this.loaded) {
+            const cacheAge = Date.now() - this.lastLoadTime;
+            if (cacheAge < this.cacheTTL) {
+                logger_1.logger.debug({ cacheAge }, 'Using cached resource index');
+                return;
+            }
+            logger_1.logger.debug('Resource cache expired, reloading...');
+        }
+        const startTime = Date.now();
+        this.resourceIndex.clear();
+        this.conflicts = [];
+        const stats = {
+            sourcesLoaded: 0,
+            resourcesIndexed: 0,
+            byType: {
+                commands: 0,
+                skills: 0,
+                mcp: 0,
+                rules: 0,
+            },
+            conflictsDetected: 0,
+            loadDuration: 0,
+        };
+        try {
+            // Collect all sources sorted by priority (descending)
+            const sources = [this.config.default_source, ...this.config.extended_sources.filter((s) => s.enabled)];
+            sources.sort((a, b) => b.priority - a.priority); // High priority first
+            logger_1.logger.info({ sourceCount: sources.length }, 'Scanning resources from all sources...');
+            // Scan each source
+            for (const source of sources) {
+                await this.scanSource(source, stats);
+                stats.sourcesLoaded++;
+            }
+            stats.conflictsDetected = this.conflicts.length;
+            stats.loadDuration = Date.now() - startTime;
+            this.stats = stats;
+            this.loaded = true;
+            this.lastLoadTime = Date.now();
+            logger_1.logger.info({
+                sourcesLoaded: stats.sourcesLoaded,
+                resourcesIndexed: stats.resourcesIndexed,
+                conflictsDetected: stats.conflictsDetected,
+                duration: stats.loadDuration,
+            }, 'Resource scanning completed');
+        }
+        catch (error) {
+            logger_1.logger.error({
+                type: 'resource',
+                operation: 'scan_resources',
+                error: error instanceof Error ? error.message : String(error),
+            }, 'Failed to scan resources');
+            throw error;
+        }
+    }
+    /**
+     * Scan resources from a single source
+     */
+    async scanSource(source, stats) {
+        logger_1.logger.debug({ source: source.name, path: source.path }, 'Scanning source...');
+        const baseDir = path.resolve(process.cwd(), 'AI-Resources', source.path);
+        // Check if source directory exists
+        try {
+            await fs.access(baseDir);
+        }
+        catch {
+            logger_1.logger.warn({ source: source.name, path: baseDir }, 'Source directory not found, skipping');
+            return;
+        }
+        // Scan each resource type
+        for (const type of this.config.resource_types) {
+            const subDir = source.resources[type];
+            if (!subDir) {
+                logger_1.logger.debug({ source: source.name, type }, 'Resource type not defined for this source, skipping');
+                continue;
+            }
+            const resourceDir = path.join(baseDir, subDir);
+            try {
+                await fs.access(resourceDir);
+            }
+            catch {
+                logger_1.logger.debug({ source: source.name, type, path: resourceDir }, 'Resource directory not found, skipping');
+                continue;
+            }
+            await this.scanResourceType(source, type, resourceDir, stats);
+        }
+    }
+    /**
+     * Scan resources of a specific type from a directory
+     */
+    async scanResourceType(source, type, dir, stats) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdc'))) {
+                    // Handle file resources (commands, rules)
+                    const resourceName = path.basename(entry.name, path.extname(entry.name));
+                    await this.indexResource(source, type, resourceName, fullPath, stats);
+                }
+                else if (entry.isDirectory()) {
+                    // Handle directory resources (skills, mcp)
+                    const skillFile = path.join(fullPath, 'SKILL.md');
+                    try {
+                        await fs.access(skillFile);
+                        await this.indexResource(source, type, entry.name, skillFile, stats);
+                    }
+                    catch {
+                        // Not a skill directory, skip
+                        logger_1.logger.debug({ dir: fullPath }, 'Directory does not contain SKILL.md, skipping');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn({
+                source: source.name,
+                type,
+                dir,
+                error: error instanceof Error ? error.message : String(error),
+            }, 'Failed to scan resource directory');
+        }
+    }
+    /**
+     * Index a single resource with conflict detection
+     */
+    async indexResource(source, type, name, filePath, stats) {
+        const resourceKey = `${type}:${name}`;
+        const existing = this.resourceIndex.get(resourceKey);
+        if (existing) {
+            // Conflict detected
+            logger_1.logger.warn({
+                resourceName: name,
+                type,
+                existingSource: existing.source,
+                existingPriority: existing.priority,
+                newSource: source.name,
+                newPriority: source.priority,
+            }, 'Resource name conflict detected');
+            // Record conflict
+            const conflict = {
+                name,
+                type,
+                conflicts: [
+                    {
+                        source: existing.source,
+                        priority: existing.priority,
+                        path: existing.path,
+                    },
+                    {
+                        source: source.name,
+                        priority: source.priority,
+                        path: filePath,
+                    },
+                ],
+                selected: source.priority > existing.priority
+                    ? { source: source.name, priority: source.priority, path: filePath }
+                    : { source: existing.source, priority: existing.priority, path: existing.path },
+            };
+            this.conflicts.push(conflict);
+            // Keep higher priority resource (already sorted by priority)
+            if (source.priority <= existing.priority) {
+                logger_1.logger.debug({
+                    resourceName: name,
+                    selectedSource: existing.source,
+                }, 'Keeping existing resource (higher priority)');
+                return;
+            }
+            logger_1.logger.debug({
+                resourceName: name,
+                selectedSource: source.name,
+            }, 'Replacing with new resource (higher priority)');
+        }
+        // Index resource
+        const metadata = {
+            id: resourceKey,
+            name,
+            type,
+            source: source.name,
+            priority: source.priority,
+            path: filePath,
+        };
+        this.resourceIndex.set(resourceKey, metadata);
+        stats.resourcesIndexed++;
+        stats.byType[type]++;
+        logger_1.logger.debug({ resourceKey, source: source.name }, 'Resource indexed');
+    }
+    /**
+     * Get all resources by type
+     */
+    getResourcesByType(type) {
+        this.ensureLoaded();
+        const results = [];
+        for (const [, metadata] of this.resourceIndex) {
+            if (metadata.type === type) {
+                results.push(metadata);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get resource by ID (type:name)
+     */
+    getResourceById(id) {
+        this.ensureLoaded();
+        return this.resourceIndex.get(id) || null;
+    }
+    /**
+     * Search resources by name
+     */
+    searchResourcesByName(name, type) {
+        this.ensureLoaded();
+        const results = [];
+        const lowerName = name.toLowerCase();
+        for (const metadata of this.resourceIndex.values()) {
+            if (type && metadata.type !== type) {
+                continue;
+            }
+            if (metadata.name.toLowerCase().includes(lowerName)) {
+                results.push(metadata);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get all detected conflicts
+     */
+    getConflicts() {
+        this.ensureLoaded();
+        return [...this.conflicts];
+    }
+    /**
+     * Get loader statistics
+     */
+    getStats() {
+        return this.stats;
+    }
+    /**
+     * Refresh resource index (clear cache and rescan)
+     */
+    async refresh() {
+        logger_1.logger.info('Refreshing resource index...');
+        this.loaded = false;
+        this.lastLoadTime = 0;
+        await this.scanResources();
+    }
+    /**
+     * Ensure resources are loaded
+     */
+    ensureLoaded() {
+        if (!this.loaded) {
+            throw new Error('Resources not loaded. Call scanResources() first.');
+        }
+    }
+}
+exports.ResourceLoader = ResourceLoader;
+// Singleton instance
+exports.resourceLoader = new ResourceLoader();
+//# sourceMappingURL=loader.js.map