claude-flow-novice 2.15.3 → 2.15.5

package/dist/services/skill-loader.js

@@ -0,0 +1,427 @@
+/**
+ * Skill Loader with Memory Budget
+ *
+ * High-performance skill loading system with:
+ * - Lazy loading (metadata at startup, content on-demand)
+ * - Memory budget enforcement (100MB default)
+ * - LRU cache with eviction
+ * - SHA-256 hash validation
+ * - <2s startup for 500 skills
+ * - <100ms cache hit, <500ms cache miss
+ *
+ * @module skill-loader
+ */ import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { LRUSkillCache } from '../lib/skill-cache.js';
+import { createLogger } from '../lib/logging.js';
+import { StandardError } from '../lib/errors.js';
+/**
+ * Skill Loader with memory budget and lazy loading
+ */ export class SkillLoader {
+    cache;
+    metadata;
+    dbService;
+    skillsBasePath;
+    logger;
+    debug;
+    maxMemoryBytes;
+    initialized = false;
+    // Loading locks (prevent duplicate loads)
+    loadingLocks = new Map();
+    // Metrics
+    metrics = {
+        hashMismatches: 0,
+        cacheInvalidations: 0
+    };
+    constructor(config){
+        this.dbService = config.dbService;
+        this.maxMemoryBytes = config.maxMemoryBytes ?? 100 * 1024 * 1024; // 100MB default
+        this.skillsBasePath = config.skillsBasePath ?? path.join(process.cwd(), '.claude/skills');
+        this.logger = config.logger ?? createLogger('skill-loader');
+        this.debug = config.debug ?? false;
+        // Initialize metadata map
+        this.metadata = new Map();
+        // Initialize LRU cache
+        this.cache = new LRUSkillCache({
+            maxMemoryBytes: this.maxMemoryBytes,
+            logger: this.logger,
+            debug: this.debug
+        });
+        if (this.debug) {
+            this.logger.info('SkillLoader initialized', {
+                maxMemoryBytes: this.maxMemoryBytes,
+                maxMemoryMB: (this.maxMemoryBytes / 1024 / 1024).toFixed(2),
+                skillsBasePath: this.skillsBasePath
+            });
+        }
+    }
+    /**
+   * Initialize loader
+   *
+   * Scans skills directory and loads metadata (NOT content).
+   * Fast: <2s for 500 skills.
+   */ async initialize() {
+        const startTime = Date.now();
+        if (this.initialized) {
+            this.logger.warn('SkillLoader already initialized');
+            return;
+        }
+        this.logger.info('Initializing SkillLoader', {
+            skillsBasePath: this.skillsBasePath
+        });
+        // Scan skills directory
+        await this.scanSkillsDirectory();
+        // Load metadata from database (if available)
+        if (this.dbService) {
+            await this.loadMetadataFromDatabase();
+        }
+        this.initialized = true;
+        const initTime = Date.now() - startTime;
+        this.logger.info('SkillLoader initialized', {
+            skillsLoaded: this.metadata.size,
+            initTimeMs: initTime
+        });
+        if (initTime >= 2000) {
+            this.logger.warn('Initialization time exceeded target', {
+                initTimeMs: initTime,
+                target: 2000
+            });
+        }
+    }
+    /**
+   * Load skill content
+   *
+   * Lazy loading: content loaded on-demand.
+   * - Cache hit: <100ms
+   * - Cache miss: <500ms (disk I/O + hash validation)
+   *
+   * @param skillId - Skill ID to load
+   * @returns Loaded skill with content
+   */ async loadSkill(skillId) {
+        const startTime = Date.now();
+        if (!this.initialized) {
+            throw new StandardError('LOADER_NOT_INITIALIZED', 'SkillLoader not initialized. Call initialize() first.');
+        }
+        // Check if already loading (prevent duplicate loads)
+        const existingLoad = this.loadingLocks.get(skillId);
+        if (existingLoad) {
+            if (this.debug) {
+                this.logger.debug('Waiting for existing load', {
+                    skillId
+                });
+            }
+            return existingLoad;
+        }
+        // Create loading promise
+        const loadPromise = this.doLoadSkill(skillId, startTime);
+        this.loadingLocks.set(skillId, loadPromise);
+        try {
+            const skill = await loadPromise;
+            return skill;
+        } finally{
+            this.loadingLocks.delete(skillId);
+        }
+    }
+    /**
+   * Internal skill loading implementation
+   */ async doLoadSkill(skillId, startTime) {
+        // Get metadata
+        const meta = this.metadata.get(skillId);
+        if (!meta) {
+            throw new StandardError('SKILL_NOT_FOUND', `Skill not found: ${skillId}`, {
+                skillId
+            });
+        }
+        // Check cache first
+        const cached = this.cache.get(skillId);
+        if (cached) {
+            const loadTime = Date.now() - startTime;
+            if (this.debug) {
+                this.logger.debug('Cache hit', {
+                    skillId,
+                    loadTimeMs: loadTime
+                });
+            }
+            // Verify hash (detect file changes)
+            const currentHash = await this.computeFileHash(meta.path);
+            if (currentHash !== meta.hash) {
+                // Hash mismatch - invalidate cache and reload
+                this.metrics.hashMismatches++;
+                this.metrics.cacheInvalidations++;
+                this.cache.delete(skillId);
+                if (this.debug) {
+                    this.logger.debug('Hash mismatch detected, reloading', {
+                        skillId,
+                        oldHash: meta.hash,
+                        newHash: currentHash
+                    });
+                }
+            // Fall through to load from disk
+            } else {
+                // Cache hit with valid hash
+                return {
+                    ...meta,
+                    content: cached
+                };
+            }
+        }
+        // Cache miss - load from disk
+        const content = await this.loadSkillFromDisk(meta);
+        const loadTime = Date.now() - startTime;
+        if (this.debug) {
+            this.logger.debug('Cache miss, loaded from disk', {
+                skillId,
+                loadTimeMs: loadTime
+            });
+        }
+        if (loadTime >= 500) {
+            this.logger.warn('Load time exceeded target', {
+                skillId,
+                loadTimeMs: loadTime,
+                target: 500
+            });
+        }
+        // Update metadata with new hash (if changed)
+        const currentHash = await this.computeFileHash(meta.path);
+        if (currentHash !== meta.hash) {
+            meta.hash = currentHash;
+            this.metrics.hashMismatches++;
+            // Update database
+            if (this.dbService) {
+                await this.updateMetadataInDatabase(meta);
+            }
+        }
+        // Cache the content
+        const contentSize = this.estimateContentSize(content);
+        this.cache.set(skillId, content, contentSize);
+        return {
+            ...meta,
+            content
+        };
+    }
+    /**
+   * Load skill content from disk
+   */ async loadSkillFromDisk(meta) {
+        const skillPath = path.join(this.skillsBasePath, meta.path);
+        try {
+            const markdown = await fs.readFile(skillPath, 'utf-8');
+            // Validate content
+            if (!markdown || markdown.trim().length === 0) {
+                throw new StandardError('EMPTY_SKILL_FILE', `Empty skill file: ${meta.id}`, {
+                    skillId: meta.id,
+                    path: skillPath
+                });
+            }
+            // Check for corrupted content (null bytes, invalid characters)
+            if (markdown.includes('\0') || /[\x00-\x08\x0B-\x0C\x0E-\x1F]/.test(markdown)) {
+                throw new StandardError('CORRUPTED_SKILL_FILE', `Corrupted skill file (invalid characters): ${meta.id}`, {
+                    skillId: meta.id,
+                    path: skillPath
+                });
+            }
+            // Validate minimum content length (reasonable skill should be >50 chars)
+            if (markdown.trim().length < 50) {
+                throw new StandardError('INVALID_SKILL_FILE', `Invalid skill file (too short): ${meta.id}`, {
+                    skillId: meta.id,
+                    path: skillPath,
+                    length: markdown.trim().length
+                });
+            }
+            // Parse frontmatter (simple implementation)
+            const { frontmatter, content } = this.parseFrontmatter(markdown);
+            return {
+                markdown,
+                frontmatter,
+                title: frontmatter?.title ?? meta.id,
+                description: frontmatter?.description
+            };
+        } catch (error) {
+            throw new StandardError('SKILL_LOAD_ERROR', `Failed to load skill from disk: ${meta.id}`, {
+                skillId: meta.id,
+                path: skillPath,
+                error: String(error)
+            });
+        }
+    }
+    /**
+   * Scan skills directory and load metadata
+   */ async scanSkillsDirectory() {
+        try {
+            const entries = await fs.readdir(this.skillsBasePath, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                if (entry.isDirectory()) {
+                    const skillId = entry.name;
+                    const skillFile = path.join(this.skillsBasePath, skillId, 'SKILL.md');
+                    try {
+                        const stat = await fs.stat(skillFile);
+                        const hash = await this.computeFileHash(path.join(skillId, 'SKILL.md'));
+                        const metadata = {
+                            id: skillId,
+                            path: path.join(skillId, 'SKILL.md'),
+                            hash,
+                            size: stat.size
+                        };
+                        this.metadata.set(skillId, metadata);
+                    } catch (error) {
+                        // Skip invalid skills
+                        if (this.debug) {
+                            this.logger.debug('Skipping invalid skill', {
+                                skillId,
+                                error: String(error)
+                            });
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            throw new StandardError('SCAN_ERROR', 'Failed to scan skills directory', {
+                skillsBasePath: this.skillsBasePath,
+                error: String(error)
+            });
+        }
+    }
+    /**
+   * Compute SHA-256 hash of file
+   */ async computeFileHash(relativePath) {
+        const fullPath = path.join(this.skillsBasePath, relativePath);
+        const content = await fs.readFile(fullPath, 'utf-8');
+        return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
+    }
+    /**
+   * Load metadata from database
+   */ async loadMetadataFromDatabase() {
+        if (!this.dbService) {
+            return;
+        }
+        try {
+            const sqliteAdapter = this.dbService.getAdapter('sqlite');
+            const rows = await sqliteAdapter.raw('SELECT id, path, hash, size, last_loaded FROM skill_metadata');
+            for (const row of rows){
+                const existing = this.metadata.get(row.id);
+                if (existing) {
+                    // Update with database values
+                    existing.lastLoaded = row.last_loaded ? new Date(row.last_loaded) : undefined;
+                }
+            }
+        } catch (error) {
+            // Table might not exist yet
+            if (this.debug) {
+                this.logger.debug('Failed to load metadata from database', {
+                    error: String(error)
+                });
+            }
+        }
+    }
+    /**
+   * Update metadata in database
+   */ async updateMetadataInDatabase(meta) {
+        if (!this.dbService) {
+            return;
+        }
+        try {
+            const sqliteAdapter = this.dbService.getAdapter('sqlite');
+            await sqliteAdapter.raw(`INSERT OR REPLACE INTO skill_metadata (id, path, hash, size, last_loaded)
+         VALUES (?, ?, ?, ?, ?)`, [
+                meta.id,
+                meta.path,
+                meta.hash,
+                meta.size,
+                new Date().toISOString()
+            ]);
+        } catch (error) {
+            if (this.debug) {
+                this.logger.debug('Failed to update metadata in database', {
+                    skillId: meta.id,
+                    error: String(error)
+                });
+            }
+        }
+    }
+    /**
+   * Parse frontmatter from markdown
+   */ parseFrontmatter(markdown) {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = markdown.match(frontmatterRegex);
+        if (!match) {
+            return {
+                content: markdown
+            };
+        }
+        const [, frontmatterText, content] = match;
+        const frontmatter = {};
+        // Simple YAML parser (key: value)
+        const lines = frontmatterText.split('\n');
+        for (const line of lines){
+            const colonIndex = line.indexOf(':');
+            if (colonIndex > 0) {
+                const key = line.substring(0, colonIndex).trim();
+                const value = line.substring(colonIndex + 1).trim();
+                frontmatter[key] = value;
+            }
+        }
+        return {
+            frontmatter,
+            content
+        };
+    }
+    /**
+   * Estimate content size in bytes
+   */ estimateContentSize(content) {
+        // Rough estimate: markdown size + frontmatter overhead
+        let size = Buffer.byteLength(content.markdown, 'utf-8');
+        if (content.frontmatter) {
+            size += JSON.stringify(content.frontmatter).length;
+        }
+        return size;
+    }
+    /**
+   * Get loader metrics
+   */ getMetrics() {
+        const cacheStats = this.cache.getStatistics();
+        const contentLoaded = this.cache.size;
+        return {
+            skillsLoaded: this.metadata.size,
+            skillContentLoaded: contentLoaded,
+            memoryUsageBytes: cacheStats.memoryUsageBytes,
+            cacheHits: cacheStats.hits,
+            cacheMisses: cacheStats.misses,
+            evictions: cacheStats.evictions,
+            hashMismatches: this.metrics.hashMismatches,
+            cacheInvalidations: this.metrics.cacheInvalidations,
+            cacheHitRate: cacheStats.hitRate
+        };
+    }
+    /**
+   * Reset metrics
+   */ resetMetrics() {
+        this.cache.resetStatistics();
+        this.metrics = {
+            hashMismatches: 0,
+            cacheInvalidations: 0
+        };
+    }
+    /**
+   * Get cache statistics
+   */ getCacheStatistics() {
+        return this.cache.getStatistics();
+    }
+    /**
+   * Get loader configuration
+   */ getConfig() {
+        return {
+            maxMemoryBytes: this.maxMemoryBytes,
+            skillsBasePath: this.skillsBasePath
+        };
+    }
+    /**
+   * Clear cache
+   */ clearCache() {
+        this.cache.clear();
+        this.logger.info('Cache cleared');
+    }
+}
+
+//# sourceMappingURL=skill-loader.js.map

package/dist/services/skill-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/skill-loader.ts"],"sourcesContent":["/**\r\n * Skill Loader with Memory Budget\r\n *\r\n * High-performance skill loading system with:\r\n * - Lazy loading (metadata at startup, content on-demand)\r\n * - Memory budget enforcement (100MB default)\r\n * - LRU cache with eviction\r\n * - SHA-256 hash validation\r\n * - <2s startup for 500 skills\r\n * - <100ms cache hit, <500ms cache miss\r\n *\r\n * @module skill-loader\r\n */\r\n\r\nimport * as fs from 'fs/promises';\r\nimport * as path from 'path';\r\nimport * as crypto from 'crypto';\r\nimport { LRUSkillCache, CacheStatistics } from '../lib/skill-cache.js';\r\nimport { DatabaseService } from '../lib/database-service.js';\r\nimport { createLogger, Logger } from '../lib/logging.js';\r\nimport { StandardError } from '../lib/errors.js';\r\n\r\n/**\r\n * Skill metadata (loaded at startup)\r\n */\r\nexport interface SkillMetadata {\r\n  /** Skill ID */\r\n  id: string;\r\n\r\n  /** Skill file path (relative to skills base) */\r\n  path: string;\r\n\r\n  /** SHA-256 content hash */\r\n  hash: string;\r\n\r\n  /** File size in bytes */\r\n  size: number;\r\n\r\n  /** Last loaded timestamp */\r\n  lastLoaded?: Date;\r\n\r\n  /** Skill content (lazy loaded) */\r\n  content?: SkillContent;\r\n}\r\n\r\n/**\r\n * Skill content (lazy loaded)\r\n */\r\nexport interface SkillContent {\r\n  /** Full markdown content */\r\n  markdown: string;\r\n\r\n  /** Parsed frontmatter (optional) */\r\n  frontmatter?: Record<string, any>;\r\n\r\n  /** Skill title */\r\n  title?: string;\r\n\r\n  /** Skill description */\r\n  description?: string;\r\n}\r\n\r\n/**\r\n * Skill with content loaded\r\n */\r\nexport interface LoadedSkill extends SkillMetadata {\r\n  /** Skill content (always defined for loaded skill) */\r\n  content: SkillContent;\r\n}\r\n\r\n/**\r\n * Loader metrics\r\n */\r\nexport interface LoaderMetrics {\r\n  /** Total skills discovered (metadata loaded) */\r\n  skillsLoaded: number;\r\n\r\n  /** Skills with content loaded */\r\n  skillContentLoaded: number;\r\n\r\n  /** Current memory usage (bytes) */\r\n  memoryUsageBytes: number;\r\n\r\n  /** Cache hits */\r\n  cacheHits: number;\r\n\r\n  /** Cache misses */\r\n  cacheMisses: number;\r\n\r\n  /** Cache evictions */\r\n  evictions: number;\r\n\r\n  /** Hash mismatches detected */\r\n  hashMismatches: number;\r\n\r\n  /** Cache invalidations */\r\n  cacheInvalidations: number;\r\n\r\n  /** Cache hit rate (0-1) */\r\n  cacheHitRate: number;\r\n}\r\n\r\n/**\r\n * Loader configuration\r\n */\r\nexport interface SkillLoaderConfig {\r\n  /** Database service */\r\n  dbService?: DatabaseService;\r\n\r\n  /** Maximum memory budget (bytes) */\r\n  maxMemoryBytes?: number;\r\n\r\n  /** Skills base path */\r\n  skillsBasePath?: string;\r\n\r\n  /** Logger instance */\r\n  logger?: Logger;\r\n\r\n  /** Enable debug logging */\r\n  debug?: boolean;\r\n}\r\n\r\n/**\r\n * Skill Loader with memory budget and lazy loading\r\n */\r\nexport class SkillLoader {\r\n  private cache: LRUSkillCache<SkillContent>;\r\n  private metadata: Map<string, SkillMetadata>;\r\n  private dbService?: DatabaseService;\r\n  private skillsBasePath: string;\r\n  private logger: Logger;\r\n  private debug: boolean;\r\n  private maxMemoryBytes: number;\r\n  private initialized: boolean = false;\r\n\r\n  // Loading locks (prevent duplicate loads)\r\n  private loadingLocks: Map<string, Promise<LoadedSkill>> = new Map();\r\n\r\n  // Metrics\r\n  private metrics = {\r\n    hashMismatches: 0,\r\n    cacheInvalidations: 0,\r\n  };\r\n\r\n  constructor(config: SkillLoaderConfig) {\r\n    this.dbService = config.dbService;\r\n    this.maxMemoryBytes = config.maxMemoryBytes ?? 100 * 1024 * 1024; // 100MB default\r\n    this.skillsBasePath = config.skillsBasePath ?? path.join(process.cwd(), '.claude/skills');\r\n    this.logger = config.logger ?? createLogger('skill-loader');\r\n    this.debug = config.debug ?? false;\r\n\r\n    // Initialize metadata map\r\n    this.metadata = new Map();\r\n\r\n    // Initialize LRU cache\r\n    this.cache = new LRUSkillCache<SkillContent>({\r\n      maxMemoryBytes: this.maxMemoryBytes,\r\n      logger: this.logger,\r\n      debug: this.debug,\r\n    });\r\n\r\n    if (this.debug) {\r\n      this.logger.info('SkillLoader initialized', {\r\n        maxMemoryBytes: this.maxMemoryBytes,\r\n        maxMemoryMB: (this.maxMemoryBytes / 1024 / 1024).toFixed(2),\r\n        skillsBasePath: this.skillsBasePath,\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Initialize loader\r\n   *\r\n   * Scans skills directory and loads metadata (NOT content).\r\n   * Fast: <2s for 500 skills.\r\n   */\r\n  async initialize(): Promise<void> {\r\n    const startTime = Date.now();\r\n\r\n    if (this.initialized) {\r\n      this.logger.warn('SkillLoader already initialized');\r\n      return;\r\n    }\r\n\r\n    this.logger.info('Initializing SkillLoader', { skillsBasePath: this.skillsBasePath });\r\n\r\n    // Scan skills directory\r\n    await this.scanSkillsDirectory();\r\n\r\n    // Load metadata from database (if available)\r\n    if (this.dbService) {\r\n      await this.loadMetadataFromDatabase();\r\n    }\r\n\r\n    this.initialized = true;\r\n\r\n    const initTime = Date.now() - startTime;\r\n    this.logger.info('SkillLoader initialized', {\r\n      skillsLoaded: this.metadata.size,\r\n      initTimeMs: initTime,\r\n    });\r\n\r\n    if (initTime >= 2000) {\r\n      this.logger.warn('Initialization time exceeded target', {\r\n        initTimeMs: initTime,\r\n        target: 2000,\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load skill content\r\n   *\r\n   * Lazy loading: content loaded on-demand.\r\n   * - Cache hit: <100ms\r\n   * - Cache miss: <500ms (disk I/O + hash validation)\r\n   *\r\n   * @param skillId - Skill ID to load\r\n   * @returns Loaded skill with content\r\n   */\r\n  async loadSkill(skillId: string): Promise<LoadedSkill> {\r\n    const startTime = Date.now();\r\n\r\n    if (!this.initialized) {\r\n      throw new StandardError(\r\n        'LOADER_NOT_INITIALIZED',\r\n        'SkillLoader not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n\r\n    // Check if already loading (prevent duplicate loads)\r\n    const existingLoad = this.loadingLocks.get(skillId);\r\n    if (existingLoad) {\r\n      if (this.debug) {\r\n        this.logger.debug('Waiting for existing load', { skillId });\r\n      }\r\n      return existingLoad;\r\n    }\r\n\r\n    // Create loading promise\r\n    const loadPromise = this.doLoadSkill(skillId, startTime);\r\n    this.loadingLocks.set(skillId, loadPromise);\r\n\r\n    try {\r\n      const skill = await loadPromise;\r\n      return skill;\r\n    } finally {\r\n      this.loadingLocks.delete(skillId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Internal skill loading implementation\r\n   */\r\n  private async doLoadSkill(skillId: string, startTime: number): Promise<LoadedSkill> {\r\n    // Get metadata\r\n    const meta = this.metadata.get(skillId);\r\n    if (!meta) {\r\n      throw new StandardError(\r\n        'SKILL_NOT_FOUND',\r\n        `Skill not found: ${skillId}`,\r\n        { skillId }\r\n      );\r\n    }\r\n\r\n    // Check cache first\r\n    const cached = this.cache.get(skillId);\r\n    if (cached) {\r\n      const loadTime = Date.now() - startTime;\r\n\r\n      if (this.debug) {\r\n        this.logger.debug('Cache hit', {\r\n          skillId,\r\n          loadTimeMs: loadTime,\r\n        });\r\n      }\r\n\r\n      // Verify hash (detect file changes)\r\n      const currentHash = await this.computeFileHash(meta.path);\r\n      if (currentHash !== meta.hash) {\r\n        // Hash mismatch - invalidate cache and reload\r\n        this.metrics.hashMismatches++;\r\n        this.metrics.cacheInvalidations++;\r\n        this.cache.delete(skillId);\r\n\r\n        if (this.debug) {\r\n          this.logger.debug('Hash mismatch detected, reloading', {\r\n            skillId,\r\n            oldHash: meta.hash,\r\n            newHash: currentHash,\r\n          });\r\n        }\r\n\r\n        // Fall through to load from disk\r\n      } else {\r\n        // Cache hit with valid hash\r\n        return {\r\n          ...meta,\r\n          content: cached,\r\n        };\r\n      }\r\n    }\r\n\r\n    // Cache miss - load from disk\r\n    const content = await this.loadSkillFromDisk(meta);\r\n    const loadTime = Date.now() - startTime;\r\n\r\n    if (this.debug) {\r\n      this.logger.debug('Cache miss, loaded from disk', {\r\n        skillId,\r\n        loadTimeMs: loadTime,\r\n      });\r\n    }\r\n\r\n    if (loadTime >= 500) {\r\n      this.logger.warn('Load time exceeded target', {\r\n        skillId,\r\n        loadTimeMs: loadTime,\r\n        target: 500,\r\n      });\r\n    }\r\n\r\n    // Update metadata with new hash (if changed)\r\n    const currentHash = await this.computeFileHash(meta.path);\r\n    if (currentHash !== meta.hash) {\r\n      meta.hash = currentHash;\r\n      this.metrics.hashMismatches++;\r\n\r\n      // Update database\r\n      if (this.dbService) {\r\n        await this.updateMetadataInDatabase(meta);\r\n      }\r\n    }\r\n\r\n    // Cache the content\r\n    const contentSize = this.estimateContentSize(content);\r\n    this.cache.set(skillId, content, contentSize);\r\n\r\n    return {\r\n      ...meta,\r\n      content,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Load skill content from disk\r\n   */\r\n  private async loadSkillFromDisk(meta: SkillMetadata): Promise<SkillContent> {\r\n    const skillPath = path.join(this.skillsBasePath, meta.path);\r\n\r\n    try {\r\n      const markdown = await fs.readFile(skillPath, 'utf-8');\r\n\r\n      // Validate content\r\n      if (!markdown || markdown.trim().length === 0) {\r\n        throw new StandardError(\r\n          'EMPTY_SKILL_FILE',\r\n          `Empty skill file: ${meta.id}`,\r\n          { skillId: meta.id, path: skillPath }\r\n        );\r\n      }\r\n\r\n      // Check for corrupted content (null bytes, invalid characters)\r\n      if (markdown.includes('\\0') || /[\\x00-\\x08\\x0B-\\x0C\\x0E-\\x1F]/.test(markdown)) {\r\n        throw new StandardError(\r\n          'CORRUPTED_SKILL_FILE',\r\n          `Corrupted skill file (invalid characters): ${meta.id}`,\r\n          { skillId: meta.id, path: skillPath }\r\n        );\r\n      }\r\n\r\n      // Validate minimum content length (reasonable skill should be >50 chars)\r\n      if (markdown.trim().length < 50) {\r\n        throw new StandardError(\r\n          'INVALID_SKILL_FILE',\r\n          `Invalid skill file (too short): ${meta.id}`,\r\n          { skillId: meta.id, path: skillPath, length: markdown.trim().length }\r\n        );\r\n      }\r\n\r\n      // Parse frontmatter (simple implementation)\r\n      const { frontmatter, content } = this.parseFrontmatter(markdown);\r\n\r\n      return {\r\n        markdown,\r\n        frontmatter,\r\n        title: frontmatter?.title ?? meta.id,\r\n        description: frontmatter?.description,\r\n      };\r\n    } catch (error) {\r\n      throw new StandardError(\r\n        'SKILL_LOAD_ERROR',\r\n        `Failed to load skill from disk: ${meta.id}`,\r\n        { skillId: meta.id, path: skillPath, error: String(error) }\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Scan skills directory and load metadata\r\n   */\r\n  private async scanSkillsDirectory(): Promise<void> {\r\n    try {\r\n      const entries = await fs.readdir(this.skillsBasePath, { withFileTypes: true });\r\n\r\n      for (const entry of entries) {\r\n        if (entry.isDirectory()) {\r\n          const skillId = entry.name;\r\n          const skillFile = path.join(this.skillsBasePath, skillId, 'SKILL.md');\r\n\r\n          try {\r\n            const stat = await fs.stat(skillFile);\r\n            const hash = await this.computeFileHash(path.join(skillId, 'SKILL.md'));\r\n\r\n            const metadata: SkillMetadata = {\r\n              id: skillId,\r\n              path: path.join(skillId, 'SKILL.md'),\r\n              hash,\r\n              size: stat.size,\r\n            };\r\n\r\n            this.metadata.set(skillId, metadata);\r\n          } catch (error) {\r\n            // Skip invalid skills\r\n            if (this.debug) {\r\n              this.logger.debug('Skipping invalid skill', {\r\n                skillId,\r\n                error: String(error),\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n    } catch (error) {\r\n      throw new StandardError(\r\n        'SCAN_ERROR',\r\n        'Failed to scan skills directory',\r\n        { skillsBasePath: this.skillsBasePath, error: String(error) }\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Compute SHA-256 hash of file\r\n   */\r\n  private async computeFileHash(relativePath: string): Promise<string> {\r\n    const fullPath = path.join(this.skillsBasePath, relativePath);\r\n    const content = await fs.readFile(fullPath, 'utf-8');\r\n    return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');\r\n  }\r\n\r\n  /**\r\n   * Load metadata from database\r\n   */\r\n  private async loadMetadataFromDatabase(): Promise<void> {\r\n    if (!this.dbService) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      const sqliteAdapter = this.dbService.getAdapter('sqlite');\r\n      const rows = await sqliteAdapter.raw<any[]>(\r\n        'SELECT id, path, hash, size, last_loaded FROM skill_metadata'\r\n      );\r\n\r\n      for (const row of rows) {\r\n        const existing = this.metadata.get(row.id);\r\n        if (existing) {\r\n          // Update with database values\r\n          existing.lastLoaded = row.last_loaded ? new Date(row.last_loaded) : undefined;\r\n        }\r\n      }\r\n    } catch (error) {\r\n      // Table might not exist yet\r\n      if (this.debug) {\r\n        this.logger.debug('Failed to load metadata from database', {\r\n          error: String(error),\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Update metadata in database\r\n   */\r\n  private async updateMetadataInDatabase(meta: SkillMetadata): Promise<void> {\r\n    if (!this.dbService) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      const sqliteAdapter = this.dbService.getAdapter('sqlite');\r\n      await sqliteAdapter.raw(\r\n        `INSERT OR REPLACE INTO skill_metadata (id, path, hash, size, last_loaded)\r\n         VALUES (?, ?, ?, ?, ?)`,\r\n        [meta.id, meta.path, meta.hash, meta.size, new Date().toISOString()]\r\n      );\r\n    } catch (error) {\r\n      if (this.debug) {\r\n        this.logger.debug('Failed to update metadata in database', {\r\n          skillId: meta.id,\r\n          error: String(error),\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Parse frontmatter from markdown\r\n   */\r\n  private parseFrontmatter(markdown: string): {\r\n    frontmatter?: Record<string, any>;\r\n    content: string;\r\n  } {\r\n    const frontmatterRegex = /^---\\s*\\n([\\s\\S]*?)\\n---\\s*\\n([\\s\\S]*)$/;\r\n    const match = markdown.match(frontmatterRegex);\r\n\r\n    if (!match) {\r\n      return { content: markdown };\r\n    }\r\n\r\n    const [, frontmatterText, content] = match;\r\n    const frontmatter: Record<string, any> = {};\r\n\r\n    // Simple YAML parser (key: value)\r\n    const lines = frontmatterText.split('\\n');\r\n    for (const line of lines) {\r\n      const colonIndex = line.indexOf(':');\r\n      if (colonIndex > 0) {\r\n        const key = line.substring(0, colonIndex).trim();\r\n        const value = line.substring(colonIndex + 1).trim();\r\n        frontmatter[key] = value;\r\n      }\r\n    }\r\n\r\n    return { frontmatter, content };\r\n  }\r\n\r\n  /**\r\n   * Estimate content size in bytes\r\n   */\r\n  private estimateContentSize(content: SkillContent): number {\r\n    // Rough estimate: markdown size + frontmatter overhead\r\n    let size = Buffer.byteLength(content.markdown, 'utf-8');\r\n\r\n    if (content.frontmatter) {\r\n      size += JSON.stringify(content.frontmatter).length;\r\n    }\r\n\r\n    return size;\r\n  }\r\n\r\n  /**\r\n   * Get loader metrics\r\n   */\r\n  getMetrics(): LoaderMetrics {\r\n    const cacheStats = this.cache.getStatistics();\r\n    const contentLoaded = this.cache.size;\r\n\r\n    return {\r\n      skillsLoaded: this.metadata.size,\r\n      skillContentLoaded: contentLoaded,\r\n      memoryUsageBytes: cacheStats.memoryUsageBytes,\r\n      cacheHits: cacheStats.hits,\r\n      cacheMisses: cacheStats.misses,\r\n      evictions: cacheStats.evictions,\r\n      hashMismatches: this.metrics.hashMismatches,\r\n      cacheInvalidations: this.metrics.cacheInvalidations,\r\n      cacheHitRate: cacheStats.hitRate,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Reset metrics\r\n   */\r\n  resetMetrics(): void {\r\n    this.cache.resetStatistics();\r\n    this.metrics = {\r\n      hashMismatches: 0,\r\n      cacheInvalidations: 0,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Get cache statistics\r\n   */\r\n  getCacheStatistics(): CacheStatistics {\r\n    return this.cache.getStatistics();\r\n  }\r\n\r\n  /**\r\n   * Get loader configuration\r\n   */\r\n  getConfig(): { maxMemoryBytes: number; skillsBasePath: string } {\r\n    return {\r\n      maxMemoryBytes: this.maxMemoryBytes,\r\n      skillsBasePath: this.skillsBasePath,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Clear cache\r\n   */\r\n  clearCache(): void {\r\n    this.cache.clear();\r\n    this.logger.info('Cache cleared');\r\n  }\r\n}\r\n"],"names":["fs","path","crypto","LRUSkillCache","createLogger","StandardError","SkillLoader","cache","metadata","dbService","skillsBasePath","logger","debug","maxMemoryBytes","initialized","loadingLocks","Map","metrics","hashMismatches","cacheInvalidations","config","join","process","cwd","info","maxMemoryMB","toFixed","initialize","startTime","Date","now","warn","scanSkillsDirectory","loadMetadataFromDatabase","initTime","skillsLoaded","size","initTimeMs","target","loadSkill","skillId","existingLoad","get","loadPromise","doLoadSkill","set","skill","delete","meta","cached","loadTime","loadTimeMs","currentHash","computeFileHash","hash","oldHash","newHash","content","loadSkillFromDisk","updateMetadataInDatabase","contentSize","estimateContentSize","skillPath","markdown","readFile","trim","length","id","includes","test","frontmatter","parseFrontmatter","title","description","error","String","entries","readdir","withFileTypes","entry","isDirectory","name","skillFile","stat","relativePath","fullPath","createHash","update","digest","sqliteAdapter","getAdapter","rows","raw","row","existing","lastLoaded","last_loaded","undefined","toISOString","frontmatterRegex","match","frontmatterText","lines","split","line","colonIndex","indexOf","key","substring","value","Buffer","byteLength","JSON","stringify","getMetrics","cacheStats","getStatistics","contentLoaded","skillContentLoaded","memoryUsageBytes","cacheHits","hits","cacheMisses","misses","evictions","cacheHitRate","hitRate","resetMetrics","resetStatistics","getCacheStatistics","getConfig","clearCache","clear"],"mappings":"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"}