claude-flow-novice 2.15.3 → 2.15.4

package/dist/cli/skill-cache-validator.js

@@ -0,0 +1,412 @@
+/**
+ * Skill Cache Validator
+ *
+ * Provides SHA256 hash-based validation for skill content integrity and cache invalidation.
+ * Ensures cached skills remain synchronized with database content hashes.
+ *
+ * @module skill-cache-validator
+ */ import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { createLogger } from '../lib/logging.js';
+/**
+ * Skill Cache Validator
+ *
+ * Validates skill content integrity using SHA256 hashing.
+ * Supports both in-memory content and file-based validation.
+ */ export class SkillCacheValidator {
+    logger;
+    hashAlgorithm = 'sha256';
+    dbService;
+    constructor(logger, dbService){
+        this.logger = logger ?? createLogger('skill-cache-validator');
+        this.dbService = dbService;
+    }
+    /**
+   * Compute SHA256 hash of skill content
+   *
+   * @param content - Skill content to hash
+   * @returns SHA256 hash as hex string
+   */ computeHash(content) {
+        return crypto.createHash(this.hashAlgorithm).update(content, 'utf8').digest('hex');
+    }
+    /**
+   * Compute SHA256 hash from file
+   *
+   * @param filePath - Path to skill file
+   * @returns SHA256 hash as hex string
+   */ async computeFileHash(filePath) {
+        return new Promise((resolve, reject)=>{
+            const hash = crypto.createHash(this.hashAlgorithm);
+            const stream = fs.createReadStream(filePath);
+            stream.on('data', (chunk)=>hash.update(chunk));
+            stream.on('end', ()=>resolve(hash.digest('hex')));
+            stream.on('error', (err)=>reject(err));
+        });
+    }
+    /**
+   * Validate skill content against expected hash
+   *
+   * @param content - Skill content to validate
+   * @param expectedHash - Expected SHA256 hash
+   * @returns Validation result
+   */ validateContent(content, expectedHash) {
+        const actualHash = this.computeHash(content);
+        if (actualHash === expectedHash) {
+            return {
+                isValid: true,
+                expectedHash,
+                actualHash
+            };
+        }
+        this.logger.warn('Skill content hash mismatch', {
+            expectedHash,
+            actualHash
+        });
+        return {
+            isValid: false,
+            expectedHash,
+            actualHash,
+            reason: 'Content hash mismatch - skill content has been modified'
+        };
+    }
+    /**
+   * Validate skill file against expected hash
+   *
+   * @param filePath - Path to skill file
+   * @param expectedHash - Expected SHA256 hash
+   * @returns Validation result
+   */ async validateFile(filePath, expectedHash) {
+        try {
+            const actualHash = await this.computeFileHash(filePath);
+            if (actualHash === expectedHash) {
+                return {
+                    isValid: true,
+                    expectedHash,
+                    actualHash
+                };
+            }
+            this.logger.warn('Skill file hash mismatch', {
+                filePath,
+                expectedHash,
+                actualHash
+            });
+            return {
+                isValid: false,
+                expectedHash,
+                actualHash,
+                reason: `File hash mismatch - skill file has been modified: ${filePath}`
+            };
+        } catch (error) {
+            this.logger.error('Failed to validate skill file', error, {
+                filePath
+            });
+            return {
+                isValid: false,
+                expectedHash,
+                reason: `Failed to read skill file: ${error.message}`
+            };
+        }
+    }
+    /**
+   * Validate cached skill entry
+   *
+   * Checks both content hash and TTL expiration.
+   *
+   * @param cachedEntry - Cached skill entry to validate
+   * @param expectedHash - Expected SHA256 hash from database
+   * @returns Validation result
+   */ validateCachedEntry(cachedEntry, expectedHash) {
+        const now = new Date();
+        // Check TTL expiration
+        if (now > cachedEntry.validUntil) {
+            return {
+                isValid: false,
+                expectedHash,
+                actualHash: cachedEntry.contentHash,
+                reason: 'Cache entry expired (TTL exceeded)'
+            };
+        }
+        // Check content hash
+        const actualHash = this.computeHash(cachedEntry.content);
+        if (actualHash !== cachedEntry.contentHash) {
+            this.logger.error('Cached entry content hash mismatch (cache corruption)', undefined, {
+                skillId: cachedEntry.skillId,
+                cachedHash: cachedEntry.contentHash,
+                actualHash
+            });
+            return {
+                isValid: false,
+                expectedHash,
+                actualHash,
+                reason: 'Cache corruption detected - cached hash does not match content'
+            };
+        }
+        // Check against expected hash from database
+        if (cachedEntry.contentHash !== expectedHash) {
+            return {
+                isValid: false,
+                expectedHash,
+                actualHash: cachedEntry.contentHash,
+                reason: 'Database content hash updated - cache invalidated'
+            };
+        }
+        return {
+            isValid: true,
+            expectedHash,
+            actualHash: cachedEntry.contentHash
+        };
+    }
+    /**
+   * Batch validate multiple skill contents
+   *
+   * @param skills - Array of skill metadata to validate
+   * @returns Map of skillId to validation result
+   */ batchValidate(skills) {
+        const results = new Map();
+        const startTime = Date.now();
+        for (const skill of skills){
+            results.set(skill.skillId, this.validateContent(skill.content, skill.expectedHash));
+        }
+        const duration = Date.now() - startTime;
+        this.logger.debug('Batch validation completed', {
+            count: skills.length,
+            durationMs: duration,
+            avgMs: duration / skills.length
+        });
+        return results;
+    }
+    /**
+   * Generate cache key for skill
+   *
+   * @param skillId - Skill identifier
+   * @param version - Skill version
+   * @returns Cache key string
+   */ generateCacheKey(skillId, version) {
+        return `skill:${skillId}:${version}`;
+    }
+    /**
+   * Check if cache entry should be invalidated based on file modification time
+   *
+   * @param filePath - Path to skill file
+   * @param cachedAt - When the entry was cached
+   * @returns True if file was modified after caching
+   */ async shouldInvalidateByFileTime(filePath, cachedAt) {
+        try {
+            const stats = await fs.promises.stat(filePath);
+            return stats.mtime > cachedAt;
+        } catch (error) {
+            this.logger.warn('Failed to check file modification time', {
+                filePath,
+                error: error.message
+            });
+            // If we can't check the file, invalidate the cache to be safe
+            return true;
+        }
+    }
+    /**
+   * Create cache entry with validation metadata
+   *
+   * @param skillId - Skill identifier
+   * @param content - Skill content
+   * @param ttlMinutes - Time-to-live in minutes (default: 5)
+   * @returns Cached skill entry
+   */ createCacheEntry(skillId, content, ttlMinutes = 5) {
+        const now = new Date();
+        const validUntil = new Date(now.getTime() + ttlMinutes * 60 * 1000);
+        return {
+            skillId,
+            content,
+            contentHash: this.computeHash(content),
+            cachedAt: now,
+            validUntil
+        };
+    }
+    /**
+   * Verify batch of hashes match their content
+   *
+   * Used for bulk cache warming and validation.
+   *
+   * @param entries - Array of cached entries to verify
+   * @returns Array of invalid skill IDs
+   */ verifyBatchIntegrity(entries) {
+        const invalidSkills = [];
+        const startTime = Date.now();
+        for (const entry of entries){
+            const actualHash = this.computeHash(entry.content);
+            if (actualHash !== entry.contentHash) {
+                invalidSkills.push(entry.skillId);
+                this.logger.error('Cache integrity check failed', undefined, {
+                    skillId: entry.skillId,
+                    expectedHash: entry.contentHash,
+                    actualHash
+                });
+            }
+        }
+        const duration = Date.now() - startTime;
+        if (invalidSkills.length > 0) {
+            this.logger.warn('Cache integrity check found corrupted entries', {
+                totalChecked: entries.length,
+                corruptedCount: invalidSkills.length,
+                corruptedSkills: invalidSkills,
+                durationMs: duration
+            });
+        } else {
+            this.logger.debug('Cache integrity check passed', {
+                entriesChecked: entries.length,
+                durationMs: duration
+            });
+        }
+        return invalidSkills;
+    }
+    /**
+   * Query skill content hashes from database in bulk
+   *
+   * Optimized single query with WHERE IN clause for performance.
+   * Performance target: <100ms for 100 skills
+   *
+   * @param skillIds - Array of skill IDs to query
+   * @returns Map of skill ID to content hash
+   */ async querySkillHashes(skillIds) {
+        if (!this.dbService) {
+            this.logger.warn('Database service not configured - cannot query skill hashes');
+            return new Map();
+        }
+        if (skillIds.length === 0) {
+            return new Map();
+        }
+        const startTime = Date.now();
+        const hashes = new Map();
+        try {
+            // Get SQLite adapter
+            const sqlite = this.dbService.getAdapter('sqlite');
+            // Build bulk query with WHERE IN clause
+            const placeholders = skillIds.map(()=>'?').join(',');
+            const sql = `
+        SELECT id, content_hash
+        FROM skills
+        WHERE id IN (${placeholders})
+      `;
+            // Execute query
+            const records = await sqlite.raw(sql, skillIds);
+            // Build hash map
+            for (const record of records){
+                hashes.set(record.id, record.content_hash);
+            }
+            const duration = Date.now() - startTime;
+            this.logger.debug('Bulk hash query completed', {
+                skillCount: skillIds.length,
+                foundCount: hashes.size,
+                durationMs: duration,
+                avgMs: duration / skillIds.length
+            });
+            // Log performance warning if exceeding target
+            if (duration > 100) {
+                this.logger.warn('Bulk hash query exceeded 100ms target', {
+                    durationMs: duration,
+                    skillCount: skillIds.length,
+                    target: 100
+                });
+            }
+            return hashes;
+        } catch (error) {
+            this.logger.error('Failed to query skill hashes', error, {
+                skillIds
+            });
+            return new Map();
+        }
+    }
+    /**
+   * Validate cached skills against database hashes in bulk
+   *
+   * Optimized for performance with single database query.
+   * Performance target: <100ms for 100 skills
+   *
+   * @param cachedSkills - Array of cached skills to validate
+   * @returns Bulk validation result with invalid skill IDs
+   */ async validateCachedSkills(cachedSkills) {
+        const startTime = Date.now();
+        if (cachedSkills.length === 0) {
+            return {
+                isValid: true,
+                invalidSkillIds: [],
+                validCount: 0,
+                invalidCount: 0,
+                durationMs: 0
+            };
+        }
+        // Extract skill IDs
+        const skillIds = cachedSkills.map((skill)=>skill.skillId);
+        // Bulk query current hashes from database (single query)
+        const currentHashes = await this.querySkillHashes(skillIds);
+        // Compare cached vs current hashes in parallel
+        const invalidSkillIds = [];
+        const comparisons = cachedSkills.map((skill)=>{
+            const currentHash = currentHashes.get(skill.skillId);
+            if (!currentHash) {
+                // Skill not found in database - consider invalid
+                invalidSkillIds.push(skill.skillId);
+                return false;
+            }
+            if (currentHash !== skill.contentHash) {
+                // Hash mismatch - cache invalid
+                invalidSkillIds.push(skill.skillId);
+                this.logger.debug('Cache invalidated for skill', {
+                    skillId: skill.skillId,
+                    cachedHash: skill.contentHash,
+                    currentHash
+                });
+                return false;
+            }
+            return true;
+        });
+        const validCount = comparisons.filter((match)=>match === true).length;
+        const invalidCount = invalidSkillIds.length;
+        const isValid = invalidCount === 0;
+        const durationMs = Date.now() - startTime;
+        this.logger.debug('Bulk cache validation completed', {
+            totalSkills: cachedSkills.length,
+            validCount,
+            invalidCount,
+            durationMs,
+            avgMs: durationMs / cachedSkills.length
+        });
+        // Log performance warning if exceeding target
+        if (durationMs > 100 && cachedSkills.length <= 100) {
+            this.logger.warn('Bulk cache validation exceeded 100ms target', {
+                durationMs,
+                skillCount: cachedSkills.length,
+                target: 100
+            });
+        }
+        return {
+            isValid,
+            invalidSkillIds,
+            validCount,
+            invalidCount,
+            durationMs
+        };
+    }
+}
+/**
+ * Singleton instance for global use
+ */ let globalValidator = null;
+/**
+ * Get or create global validator instance
+ *
+ * @param logger - Optional logger instance
+ * @returns Global validator instance
+ */ export function getGlobalValidator(logger) {
+    if (!globalValidator) {
+        globalValidator = new SkillCacheValidator(logger);
+    }
+    return globalValidator;
+}
+/**
+ * Set global validator instance
+ *
+ * @param validator - Validator instance to use globally
+ */ export function setGlobalValidator(validator) {
+    globalValidator = validator;
+}
+
+//# sourceMappingURL=skill-cache-validator.js.map

package/dist/cli/skill-cache-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/skill-cache-validator.ts"],"sourcesContent":["/**\r\n * Skill Cache Validator\r\n *\r\n * Provides SHA256 hash-based validation for skill content integrity and cache invalidation.\r\n * Ensures cached skills remain synchronized with database content hashes.\r\n *\r\n * @module skill-cache-validator\r\n */\r\n\r\nimport * as crypto from 'crypto';\r\nimport * as fs from 'fs';\r\nimport { createLogger, Logger } from '../lib/logging.js';\r\nimport { DatabaseService } from '../lib/database-service.js';\r\n\r\n/**\r\n * Cache validation result\r\n */\r\nexport interface ValidationResult {\r\n  isValid: boolean;\r\n  expectedHash: string;\r\n  actualHash?: string;\r\n  reason?: string;\r\n}\r\n\r\n/**\r\n * Skill content metadata for validation\r\n */\r\nexport interface SkillContentMetadata {\r\n  skillId: string;\r\n  content: string;\r\n  filePath?: string;\r\n  lastModified?: Date;\r\n}\r\n\r\n/**\r\n * Cache entry with validation metadata\r\n */\r\nexport interface CachedSkillEntry {\r\n  skillId: string;\r\n  content: string;\r\n  contentHash: string;\r\n  cachedAt: Date;\r\n  validUntil: Date;\r\n}\r\n\r\n/**\r\n * Skill Cache Validator\r\n *\r\n * Validates skill content integrity using SHA256 hashing.\r\n * Supports both in-memory content and file-based validation.\r\n */\r\nexport class SkillCacheValidator {\r\n  private logger: Logger;\r\n  private hashAlgorithm: string = 'sha256';\r\n  private dbService?: DatabaseService;\r\n\r\n  constructor(logger?: Logger, dbService?: DatabaseService) {\r\n    this.logger = logger ?? createLogger('skill-cache-validator');\r\n    this.dbService = dbService;\r\n  }\r\n\r\n  /**\r\n   * Compute SHA256 hash of skill content\r\n   *\r\n   * @param content - Skill content to hash\r\n   * @returns SHA256 hash as hex string\r\n   */\r\n  computeHash(content: string): string {\r\n    return crypto\r\n      .createHash(this.hashAlgorithm)\r\n      .update(content, 'utf8')\r\n      .digest('hex');\r\n  }\r\n\r\n  /**\r\n   * Compute SHA256 hash from file\r\n   *\r\n   * @param filePath - Path to skill file\r\n   * @returns SHA256 hash as hex string\r\n   */\r\n  async computeFileHash(filePath: string): Promise<string> {\r\n    return new Promise((resolve, reject) => {\r\n      const hash = crypto.createHash(this.hashAlgorithm);\r\n      const stream = fs.createReadStream(filePath);\r\n\r\n      stream.on('data', (chunk) => hash.update(chunk));\r\n      stream.on('end', () => resolve(hash.digest('hex')));\r\n      stream.on('error', (err) => reject(err));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Validate skill content against expected hash\r\n   *\r\n   * @param content - Skill content to validate\r\n   * @param expectedHash - Expected SHA256 hash\r\n   * @returns Validation result\r\n   */\r\n  validateContent(content: string, expectedHash: string): ValidationResult {\r\n    const actualHash = this.computeHash(content);\r\n\r\n    if (actualHash === expectedHash) {\r\n      return {\r\n        isValid: true,\r\n        expectedHash,\r\n        actualHash,\r\n      };\r\n    }\r\n\r\n    this.logger.warn('Skill content hash mismatch', {\r\n      expectedHash,\r\n      actualHash,\r\n    });\r\n\r\n    return {\r\n      isValid: false,\r\n      expectedHash,\r\n      actualHash,\r\n      reason: 'Content hash mismatch - skill content has been modified',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Validate skill file against expected hash\r\n   *\r\n   * @param filePath - Path to skill file\r\n   * @param expectedHash - Expected SHA256 hash\r\n   * @returns Validation result\r\n   */\r\n  async validateFile(filePath: string, expectedHash: string): Promise<ValidationResult> {\r\n    try {\r\n      const actualHash = await this.computeFileHash(filePath);\r\n\r\n      if (actualHash === expectedHash) {\r\n        return {\r\n          isValid: true,\r\n          expectedHash,\r\n          actualHash,\r\n        };\r\n      }\r\n\r\n      this.logger.warn('Skill file hash mismatch', {\r\n        filePath,\r\n        expectedHash,\r\n        actualHash,\r\n      });\r\n\r\n      return {\r\n        isValid: false,\r\n        expectedHash,\r\n        actualHash,\r\n        reason: `File hash mismatch - skill file has been modified: ${filePath}`,\r\n      };\r\n    } catch (error) {\r\n      this.logger.error('Failed to validate skill file', error as Error, { filePath });\r\n\r\n      return {\r\n        isValid: false,\r\n        expectedHash,\r\n        reason: `Failed to read skill file: ${(error as Error).message}`,\r\n      };\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate cached skill entry\r\n   *\r\n   * Checks both content hash and TTL expiration.\r\n   *\r\n   * @param cachedEntry - Cached skill entry to validate\r\n   * @param expectedHash - Expected SHA256 hash from database\r\n   * @returns Validation result\r\n   */\r\n  validateCachedEntry(\r\n    cachedEntry: CachedSkillEntry,\r\n    expectedHash: string\r\n  ): ValidationResult {\r\n    const now = new Date();\r\n\r\n    // Check TTL expiration\r\n    if (now > cachedEntry.validUntil) {\r\n      return {\r\n        isValid: false,\r\n        expectedHash,\r\n        actualHash: cachedEntry.contentHash,\r\n        reason: 'Cache entry expired (TTL exceeded)',\r\n      };\r\n    }\r\n\r\n    // Check content hash\r\n    const actualHash = this.computeHash(cachedEntry.content);\r\n\r\n    if (actualHash !== cachedEntry.contentHash) {\r\n      this.logger.error('Cached entry content hash mismatch (cache corruption)', undefined, {\r\n        skillId: cachedEntry.skillId,\r\n        cachedHash: cachedEntry.contentHash,\r\n        actualHash,\r\n      });\r\n\r\n      return {\r\n        isValid: false,\r\n        expectedHash,\r\n        actualHash,\r\n        reason: 'Cache corruption detected - cached hash does not match content',\r\n      };\r\n    }\r\n\r\n    // Check against expected hash from database\r\n    if (cachedEntry.contentHash !== expectedHash) {\r\n      return {\r\n        isValid: false,\r\n        expectedHash,\r\n        actualHash: cachedEntry.contentHash,\r\n        reason: 'Database content hash updated - cache invalidated',\r\n      };\r\n    }\r\n\r\n    return {\r\n      isValid: true,\r\n      expectedHash,\r\n      actualHash: cachedEntry.contentHash,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Batch validate multiple skill contents\r\n   *\r\n   * @param skills - Array of skill metadata to validate\r\n   * @returns Map of skillId to validation result\r\n   */\r\n  batchValidate(\r\n    skills: Array<{ skillId: string; content: string; expectedHash: string }>\r\n  ): Map<string, ValidationResult> {\r\n    const results = new Map<string, ValidationResult>();\r\n    const startTime = Date.now();\r\n\r\n    for (const skill of skills) {\r\n      results.set(\r\n        skill.skillId,\r\n        this.validateContent(skill.content, skill.expectedHash)\r\n      );\r\n    }\r\n\r\n    const duration = Date.now() - startTime;\r\n    this.logger.debug('Batch validation completed', {\r\n      count: skills.length,\r\n      durationMs: duration,\r\n      avgMs: duration / skills.length,\r\n    });\r\n\r\n    return results;\r\n  }\r\n\r\n  /**\r\n   * Generate cache key for skill\r\n   *\r\n   * @param skillId - Skill identifier\r\n   * @param version - Skill version\r\n   * @returns Cache key string\r\n   */\r\n  generateCacheKey(skillId: string, version: string): string {\r\n    return `skill:${skillId}:${version}`;\r\n  }\r\n\r\n  /**\r\n   * Check if cache entry should be invalidated based on file modification time\r\n   *\r\n   * @param filePath - Path to skill file\r\n   * @param cachedAt - When the entry was cached\r\n   * @returns True if file was modified after caching\r\n   */\r\n  async shouldInvalidateByFileTime(\r\n    filePath: string,\r\n    cachedAt: Date\r\n  ): Promise<boolean> {\r\n    try {\r\n      const stats = await fs.promises.stat(filePath);\r\n      return stats.mtime > cachedAt;\r\n    } catch (error) {\r\n      this.logger.warn('Failed to check file modification time', {\r\n        filePath,\r\n        error: (error as Error).message,\r\n      });\r\n      // If we can't check the file, invalidate the cache to be safe\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create cache entry with validation metadata\r\n   *\r\n   * @param skillId - Skill identifier\r\n   * @param content - Skill content\r\n   * @param ttlMinutes - Time-to-live in minutes (default: 5)\r\n   * @returns Cached skill entry\r\n   */\r\n  createCacheEntry(\r\n    skillId: string,\r\n    content: string,\r\n    ttlMinutes: number = 5\r\n  ): CachedSkillEntry {\r\n    const now = new Date();\r\n    const validUntil = new Date(now.getTime() + ttlMinutes * 60 * 1000);\r\n\r\n    return {\r\n      skillId,\r\n      content,\r\n      contentHash: this.computeHash(content),\r\n      cachedAt: now,\r\n      validUntil,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Verify batch of hashes match their content\r\n   *\r\n   * Used for bulk cache warming and validation.\r\n   *\r\n   * @param entries - Array of cached entries to verify\r\n   * @returns Array of invalid skill IDs\r\n   */\r\n  verifyBatchIntegrity(entries: CachedSkillEntry[]): string[] {\r\n    const invalidSkills: string[] = [];\r\n    const startTime = Date.now();\r\n\r\n    for (const entry of entries) {\r\n      const actualHash = this.computeHash(entry.content);\r\n\r\n      if (actualHash !== entry.contentHash) {\r\n        invalidSkills.push(entry.skillId);\r\n        this.logger.error('Cache integrity check failed', undefined, {\r\n          skillId: entry.skillId,\r\n          expectedHash: entry.contentHash,\r\n          actualHash,\r\n        });\r\n      }\r\n    }\r\n\r\n    const duration = Date.now() - startTime;\r\n\r\n    if (invalidSkills.length > 0) {\r\n      this.logger.warn('Cache integrity check found corrupted entries', {\r\n        totalChecked: entries.length,\r\n        corruptedCount: invalidSkills.length,\r\n        corruptedSkills: invalidSkills,\r\n        durationMs: duration,\r\n      });\r\n    } else {\r\n      this.logger.debug('Cache integrity check passed', {\r\n        entriesChecked: entries.length,\r\n        durationMs: duration,\r\n      });\r\n    }\r\n\r\n    return invalidSkills;\r\n  }\r\n\r\n  /**\r\n   * Query skill content hashes from database in bulk\r\n   *\r\n   * Optimized single query with WHERE IN clause for performance.\r\n   * Performance target: <100ms for 100 skills\r\n   *\r\n   * @param skillIds - Array of skill IDs to query\r\n   * @returns Map of skill ID to content hash\r\n   */\r\n  async querySkillHashes(skillIds: string[]): Promise<Map<string, string>> {\r\n    if (!this.dbService) {\r\n      this.logger.warn('Database service not configured - cannot query skill hashes');\r\n      return new Map();\r\n    }\r\n\r\n    if (skillIds.length === 0) {\r\n      return new Map();\r\n    }\r\n\r\n    const startTime = Date.now();\r\n    const hashes = new Map<string, string>();\r\n\r\n    try {\r\n      // Get SQLite adapter\r\n      const sqlite = this.dbService.getAdapter('sqlite');\r\n\r\n      // Build bulk query with WHERE IN clause\r\n      const placeholders = skillIds.map(() => '?').join(',');\r\n      const sql = `\r\n        SELECT id, content_hash\r\n        FROM skills\r\n        WHERE id IN (${placeholders})\r\n      `;\r\n\r\n      // Execute query\r\n      const records = await sqlite.raw<Array<{ id: string; content_hash: string }>>(\r\n        sql,\r\n        skillIds\r\n      );\r\n\r\n      // Build hash map\r\n      for (const record of records) {\r\n        hashes.set(record.id, record.content_hash);\r\n      }\r\n\r\n      const duration = Date.now() - startTime;\r\n\r\n      this.logger.debug('Bulk hash query completed', {\r\n        skillCount: skillIds.length,\r\n        foundCount: hashes.size,\r\n        durationMs: duration,\r\n        avgMs: duration / skillIds.length,\r\n      });\r\n\r\n      // Log performance warning if exceeding target\r\n      if (duration > 100) {\r\n        this.logger.warn('Bulk hash query exceeded 100ms target', {\r\n          durationMs: duration,\r\n          skillCount: skillIds.length,\r\n          target: 100,\r\n        });\r\n      }\r\n\r\n      return hashes;\r\n    } catch (error) {\r\n      this.logger.error('Failed to query skill hashes', error as Error, {\r\n        skillIds,\r\n      });\r\n\r\n      return new Map();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate cached skills against database hashes in bulk\r\n   *\r\n   * Optimized for performance with single database query.\r\n   * Performance target: <100ms for 100 skills\r\n   *\r\n   * @param cachedSkills - Array of cached skills to validate\r\n   * @returns Bulk validation result with invalid skill IDs\r\n   */\r\n  async validateCachedSkills(\r\n    cachedSkills: CachedSkillEntry[]\r\n  ): Promise<{\r\n    isValid: boolean;\r\n    invalidSkillIds: string[];\r\n    validCount: number;\r\n    invalidCount: number;\r\n    durationMs: number;\r\n  }> {\r\n    const startTime = Date.now();\r\n\r\n    if (cachedSkills.length === 0) {\r\n      return {\r\n        isValid: true,\r\n        invalidSkillIds: [],\r\n        validCount: 0,\r\n        invalidCount: 0,\r\n        durationMs: 0,\r\n      };\r\n    }\r\n\r\n    // Extract skill IDs\r\n    const skillIds = cachedSkills.map((skill) => skill.skillId);\r\n\r\n    // Bulk query current hashes from database (single query)\r\n    const currentHashes = await this.querySkillHashes(skillIds);\r\n\r\n    // Compare cached vs current hashes in parallel\r\n    const invalidSkillIds: string[] = [];\r\n    const comparisons = cachedSkills.map((skill) => {\r\n      const currentHash = currentHashes.get(skill.skillId);\r\n\r\n      if (!currentHash) {\r\n        // Skill not found in database - consider invalid\r\n        invalidSkillIds.push(skill.skillId);\r\n        return false;\r\n      }\r\n\r\n      if (currentHash !== skill.contentHash) {\r\n        // Hash mismatch - cache invalid\r\n        invalidSkillIds.push(skill.skillId);\r\n        this.logger.debug('Cache invalidated for skill', {\r\n          skillId: skill.skillId,\r\n          cachedHash: skill.contentHash,\r\n          currentHash,\r\n        });\r\n        return false;\r\n      }\r\n\r\n      return true;\r\n    });\r\n\r\n    const validCount = comparisons.filter((match) => match === true).length;\r\n    const invalidCount = invalidSkillIds.length;\r\n    const isValid = invalidCount === 0;\r\n    const durationMs = Date.now() - startTime;\r\n\r\n    this.logger.debug('Bulk cache validation completed', {\r\n      totalSkills: cachedSkills.length,\r\n      validCount,\r\n      invalidCount,\r\n      durationMs,\r\n      avgMs: durationMs / cachedSkills.length,\r\n    });\r\n\r\n    // Log performance warning if exceeding target\r\n    if (durationMs > 100 && cachedSkills.length <= 100) {\r\n      this.logger.warn('Bulk cache validation exceeded 100ms target', {\r\n        durationMs,\r\n        skillCount: cachedSkills.length,\r\n        target: 100,\r\n      });\r\n    }\r\n\r\n    return {\r\n      isValid,\r\n      invalidSkillIds,\r\n      validCount,\r\n      invalidCount,\r\n      durationMs,\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Singleton instance for global use\r\n */\r\nlet globalValidator: SkillCacheValidator | null = null;\r\n\r\n/**\r\n * Get or create global validator instance\r\n *\r\n * @param logger - Optional logger instance\r\n * @returns Global validator instance\r\n */\r\nexport function getGlobalValidator(logger?: Logger): SkillCacheValidator {\r\n  if (!globalValidator) {\r\n    globalValidator = new SkillCacheValidator(logger);\r\n  }\r\n  return globalValidator;\r\n}\r\n\r\n/**\r\n * Set global validator instance\r\n *\r\n * @param validator - Validator instance to use globally\r\n */\r\nexport function setGlobalValidator(validator: SkillCacheValidator): void {\r\n  globalValidator = validator;\r\n}\r\n"],"names":["crypto","fs","createLogger","SkillCacheValidator","logger","hashAlgorithm","dbService","computeHash","content","createHash","update","digest","computeFileHash","filePath","Promise","resolve","reject","hash","stream","createReadStream","on","chunk","err","validateContent","expectedHash","actualHash","isValid","warn","reason","validateFile","error","message","validateCachedEntry","cachedEntry","now","Date","validUntil","contentHash","undefined","skillId","cachedHash","batchValidate","skills","results","Map","startTime","skill","set","duration","debug","count","length","durationMs","avgMs","generateCacheKey","version","shouldInvalidateByFileTime","cachedAt","stats","promises","stat","mtime","createCacheEntry","ttlMinutes","getTime","verifyBatchIntegrity","entries","invalidSkills","entry","push","totalChecked","corruptedCount","corruptedSkills","entriesChecked","querySkillHashes","skillIds","hashes","sqlite","getAdapter","placeholders","map","join","sql","records","raw","record","id","content_hash","skillCount","foundCount","size","target","validateCachedSkills","cachedSkills","invalidSkillIds","validCount","invalidCount","currentHashes","comparisons","currentHash","get","filter","match","totalSkills","globalValidator","getGlobalValidator","setGlobalValidator","validator"],"mappings":"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"}