@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
179 lines • 22.2 kB
JavaScript
/**
* Utility class for efficient file discovery operations
* Provides optimized file search with caching and security
*
* IMPLEMENTATION (PR #503 - PR #496 Recommendation):
* 1. PERFORMANCE: Single readdir operation instead of multiple file checks
* 2. PERFORMANCE: 5-second cache TTL for repeated searches
* 3. SECURITY: Unicode normalization for all search inputs
* 4. MEMORY: Efficient cache management with 100 entry limit
*
* This addresses the PR #496 review recommendation to extract file discovery
* logic to a reusable utility class for better performance and maintainability.
*/
import * as path from 'path';
import { logger } from './logger.js';
import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
import { FileOperationsService } from '../services/FileOperationsService.js';
import { FileLockManager } from '../security/fileLockManager.js';
// Singleton file operations service for static methods
let fileOperationsService = null;
function getFileOperationsService() {
if (!fileOperationsService) {
fileOperationsService = new FileOperationsService(new FileLockManager());
}
return fileOperationsService;
}
export class FileDiscoveryUtil {
static CACHE_TTL = 5000; // 5 seconds cache TTL
static cache = new Map();
/**
* Find files in a directory with optimized search
* Uses single readdir operation and filters results
*/
static async findFiles(directory, searchName, options = {}) {
const { extensions = ['.json', '.yaml', '.yml', '.md'], partialMatch = true, maxResults = 10, cacheResults = true } = options;
// Normalize search name for security
const normalizedSearch = UnicodeValidator.normalize(searchName);
if (!normalizedSearch.isValid) {
logger.warn('Invalid Unicode in search name', {
issues: normalizedSearch.detectedIssues
});
return [];
}
const safeName = normalizedSearch.normalizedContent.toLowerCase();
// Check cache if enabled
const cacheKey = `${directory}:${safeName}:${JSON.stringify(options)}`;
if (cacheResults) {
const cached = this.getCached(cacheKey);
if (cached) {
logger.debug('File search cache hit', { directory, searchName });
return cached;
}
}
try {
// Single readdir operation for efficiency
const fileOps = getFileOperationsService();
const files = await fileOps.listDirectory(directory);
// Build search patterns
const searchPatterns = this.buildSearchPatterns(safeName, extensions);
// Filter files efficiently
const matches = [];
for (const file of files) {
const fileLower = file.toLowerCase();
// Check each pattern
for (const pattern of searchPatterns) {
if (this.matchesPattern(fileLower, pattern, partialMatch)) {
const fullPath = path.join(directory, file);
matches.push(fullPath);
if (matches.length >= maxResults) {
break;
}
}
}
if (matches.length >= maxResults) {
break;
}
}
// Cache results if enabled
if (cacheResults && matches.length > 0) {
this.setCached(cacheKey, matches);
}
// Log file discovery for monitoring
if (matches.length > 0) {
logger.debug('Files discovered', {
directory,
searchName,
count: matches.length
});
}
return matches;
}
catch (error) {
logger.error('File discovery failed', {
directory,
searchName,
error: error instanceof Error ? error.message : String(error)
});
return [];
}
}
/**
* Build search patterns for different file extensions
*/
static buildSearchPatterns(baseName, extensions) {
const patterns = [baseName];
// Add extension variations
for (const ext of extensions) {
patterns.push(`${baseName}${ext}`);
}
// Add common variations
const nameWithoutExtension = baseName.replace(/\.[^.]+$/, '');
if (nameWithoutExtension !== baseName) {
patterns.push(nameWithoutExtension);
for (const ext of extensions) {
patterns.push(`${nameWithoutExtension}${ext}`);
}
}
return patterns;
}
/**
* Check if filename matches pattern
*/
static matchesPattern(filename, pattern, partialMatch) {
if (partialMatch) {
return filename.includes(pattern);
}
return filename === pattern;
}
/**
* Get cached results if still valid
*/
static getCached(key) {
const entry = this.cache.get(key);
if (!entry)
return null;
const age = Date.now() - entry.timestamp;
if (age > this.CACHE_TTL) {
this.cache.delete(key);
return null;
}
return entry.files;
}
/**
* Cache results with timestamp
*/
static setCached(key, files) {
// Limit cache size to prevent memory issues
if (this.cache.size > 100) {
// Remove oldest entries
const entries = Array.from(this.cache.entries());
entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
for (let i = 0; i < 50; i++) {
this.cache.delete(entries[i][0]);
}
}
this.cache.set(key, {
files,
timestamp: Date.now()
});
}
/**
* Clear the cache
*/
static clearCache() {
this.cache.clear();
logger.debug('File discovery cache cleared');
}
/**
* Find a single file (convenience method)
*/
static async findFile(directory, searchName, options) {
const files = await this.findFiles(directory, searchName, {
...options,
maxResults: 1
});
return files.length > 0 ? files[0] : null;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileDiscoveryUtil.js","sourceRoot":"","sources":["../../src/utils/FileDiscoveryUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAA0B,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AACrG,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEjE,uDAAuD;AACvD,IAAI,qBAAqB,GAAkC,IAAI,CAAC;AAEhE,SAAS,wBAAwB;IAC/B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC3B,qBAAqB,GAAG,IAAI,qBAAqB,CAAC,IAAI,eAAe,EAAE,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,qBAAqB,CAAC;AAC/B,CAAC;AAcD,MAAM,OAAO,iBAAiB;IACpB,MAAM,CAAU,SAAS,GAAG,IAAI,CAAC,CAAC,sBAAsB;IACxD,MAAM,CAAC,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAErD;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,SAAS,CACpB,SAAiB,EACjB,UAAkB,EAClB,UAA6B,EAAE;QAE/B,MAAM,EACJ,UAAU,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAC9C,YAAY,GAAG,IAAI,EACnB,UAAU,GAAG,EAAE,EACf,YAAY,GAAG,IAAI,EACpB,GAAG,OAAO,CAAC;QAEZ,qCAAqC;QACrC,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,gCAAgC,EAAE;gBAC5C,MAAM,EAAE,gBAAgB,CAAC,cAAc;aACxC,CAAC,CAAC;YACH,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;QAElE,yBAAyB;QACzB,MAAM,QAAQ,GAAG,GAAG,SAAS,IAAI,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QACvE,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACxC,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;gBACjE,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC;QAED,IAAI,CAAC;YACH,0CAA0C;YAC1C,MAAM,OAAO,GAAG,wBAAwB,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YAErD,wBAAwB;YACxB,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAEtE,2BAA2B;YAC3B,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;gBAErC,qBAAqB;gBACrB,KAAK,MAAM,OAAO,IAAI,cAAc,EAAE,CAAC;oBACrC,IAAI,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC;wBAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;wBAC5C,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBAEvB,IAAI,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;4BACjC,MAAM;wBACR,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,IAAI,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;oBACjC,MAAM;gBACR,CAAC;YACH,CAAC;YAED,2BAA2B;YAC3B,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACpC,CAAC;YAED,oCAAoC;YACpC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE;oBAC/B,SAAS;oBACT,UAAU;oBACV,KAAK,EAAE,OAAO,CAAC,MAAM;iBACtB,CAAC,CAAC;YACL,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE;gBACpC,SAAS;gBACT,UAAU;gBACV,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAC9D,CAAC,CAAC;YACH,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,mBAAmB,CAAC,QAAgB,EAAE,UAAoB;QACvE,MAAM,QAAQ,GAAa,CAAC,QAAQ,CAAC,CAAC;QAEtC,2BAA2B;QAC3B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,GAAG,GAAG,EAAE,CAAC,CAAC;QACrC,CAAC;QAED,wBAAwB;QACxB,MAAM,oBAAoB,GAAG,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC9D,IAAI,oBAAoB,KAAK,QAAQ,EAAE,CAAC;YACtC,QAAQ,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;YACpC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC7B,QAAQ,CAAC,IAAI,CAAC,GAAG,oBAAoB,GAAG,GAAG,EAAE,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,cAAc,CAAC,QAAgB,EAAE,OAAe,EAAE,YAAqB;QACpF,IAAI,YAAY,EAAE,CAAC;YACjB,OAAO,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QACD,OAAO,QAAQ,KAAK,OAAO,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,SAAS,CAAC,GAAW;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QAExB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC;QACzC,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,SAAS,CAAC,GAAW,EAAE,KAAe;QACnD,4CAA4C;QAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC;YAC1B,wBAAwB;YACxB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;YAClB,KAAK;YACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU;QACf,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,MAAM,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,QAAQ,CACnB,SAAiB,EACjB,UAAkB,EAClB,OAA2B;QAE3B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE;YACxD,GAAG,OAAO;YACV,UAAU,EAAE,CAAC;SACd,CAAC,CAAC;QACH,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5C,CAAC","sourcesContent":["/**\n * Utility class for efficient file discovery operations\n * Provides optimized file search with caching and security\n * \n * IMPLEMENTATION (PR #503 - PR #496 Recommendation):\n * 1. PERFORMANCE: Single readdir operation instead of multiple file checks\n * 2. PERFORMANCE: 5-second cache TTL for repeated searches\n * 3. SECURITY: Unicode normalization for all search inputs\n * 4. MEMORY: Efficient cache management with 100 entry limit\n * \n * This addresses the PR #496 review recommendation to extract file discovery\n * logic to a reusable utility class for better performance and maintainability.\n */\n\nimport * as path from 'path';\nimport { logger } from './logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { IFileOperationsService, FileOperationsService } from '../services/FileOperationsService.js';\nimport { FileLockManager } from '../security/fileLockManager.js';\n\n// Singleton file operations service for static methods\nlet fileOperationsService: IFileOperationsService | null = null;\n\nfunction getFileOperationsService(): IFileOperationsService {\n  if (!fileOperationsService) {\n    fileOperationsService = new FileOperationsService(new FileLockManager());\n  }\n  return fileOperationsService;\n}\n\nexport interface FileSearchOptions {\n  extensions?: string[];\n  partialMatch?: boolean;\n  maxResults?: number;\n  cacheResults?: boolean;\n}\n\ninterface CacheEntry {\n  files: string[];\n  timestamp: number;\n}\n\nexport class FileDiscoveryUtil {\n  private static readonly CACHE_TTL = 5000; // 5 seconds cache TTL\n  private static cache = new Map<string, CacheEntry>();\n  \n  /**\n   * Find files in a directory with optimized search\n   * Uses single readdir operation and filters results\n   */\n  static async findFiles(\n    directory: string,\n    searchName: string,\n    options: FileSearchOptions = {}\n  ): Promise<string[]> {\n    const {\n      extensions = ['.json', '.yaml', '.yml', '.md'],\n      partialMatch = true,\n      maxResults = 10,\n      cacheResults = true\n    } = options;\n    \n    // Normalize search name for security\n    const normalizedSearch = UnicodeValidator.normalize(searchName);\n    if (!normalizedSearch.isValid) {\n      logger.warn('Invalid Unicode in search name', {\n        issues: normalizedSearch.detectedIssues\n      });\n      return [];\n    }\n    const safeName = normalizedSearch.normalizedContent.toLowerCase();\n    \n    // Check cache if enabled\n    const cacheKey = `${directory}:${safeName}:${JSON.stringify(options)}`;\n    if (cacheResults) {\n      const cached = this.getCached(cacheKey);\n      if (cached) {\n        logger.debug('File search cache hit', { directory, searchName });\n        return cached;\n      }\n    }\n    \n    try {\n      // Single readdir operation for efficiency\n      const fileOps = getFileOperationsService();\n      const files = await fileOps.listDirectory(directory);\n      \n      // Build search patterns\n      const searchPatterns = this.buildSearchPatterns(safeName, extensions);\n      \n      // Filter files efficiently\n      const matches: string[] = [];\n      for (const file of files) {\n        const fileLower = file.toLowerCase();\n        \n        // Check each pattern\n        for (const pattern of searchPatterns) {\n          if (this.matchesPattern(fileLower, pattern, partialMatch)) {\n            const fullPath = path.join(directory, file);\n            matches.push(fullPath);\n            \n            if (matches.length >= maxResults) {\n              break;\n            }\n          }\n        }\n        \n        if (matches.length >= maxResults) {\n          break;\n        }\n      }\n      \n      // Cache results if enabled\n      if (cacheResults && matches.length > 0) {\n        this.setCached(cacheKey, matches);\n      }\n      \n      // Log file discovery for monitoring\n      if (matches.length > 0) {\n        logger.debug('Files discovered', {\n          directory,\n          searchName,\n          count: matches.length\n        });\n      }\n      \n      return matches;\n    } catch (error) {\n      logger.error('File discovery failed', {\n        directory,\n        searchName,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      return [];\n    }\n  }\n  \n  /**\n   * Build search patterns for different file extensions\n   */\n  private static buildSearchPatterns(baseName: string, extensions: string[]): string[] {\n    const patterns: string[] = [baseName];\n    \n    // Add extension variations\n    for (const ext of extensions) {\n      patterns.push(`${baseName}${ext}`);\n    }\n    \n    // Add common variations\n    const nameWithoutExtension = baseName.replace(/\\.[^.]+$/, '');\n    if (nameWithoutExtension !== baseName) {\n      patterns.push(nameWithoutExtension);\n      for (const ext of extensions) {\n        patterns.push(`${nameWithoutExtension}${ext}`);\n      }\n    }\n    \n    return patterns;\n  }\n  \n  /**\n   * Check if filename matches pattern\n   */\n  private static matchesPattern(filename: string, pattern: string, partialMatch: boolean): boolean {\n    if (partialMatch) {\n      return filename.includes(pattern);\n    }\n    return filename === pattern;\n  }\n  \n  /**\n   * Get cached results if still valid\n   */\n  private static getCached(key: string): string[] | null {\n    const entry = this.cache.get(key);\n    if (!entry) return null;\n    \n    const age = Date.now() - entry.timestamp;\n    if (age > this.CACHE_TTL) {\n      this.cache.delete(key);\n      return null;\n    }\n    \n    return entry.files;\n  }\n  \n  /**\n   * Cache results with timestamp\n   */\n  private static setCached(key: string, files: string[]): void {\n    // Limit cache size to prevent memory issues\n    if (this.cache.size > 100) {\n      // Remove oldest entries\n      const entries = Array.from(this.cache.entries());\n      entries.sort((a, b) => a[1].timestamp - b[1].timestamp);\n      for (let i = 0; i < 50; i++) {\n        this.cache.delete(entries[i][0]);\n      }\n    }\n    \n    this.cache.set(key, {\n      files,\n      timestamp: Date.now()\n    });\n  }\n  \n  /**\n   * Clear the cache\n   */\n  static clearCache(): void {\n    this.cache.clear();\n    logger.debug('File discovery cache cleared');\n  }\n  \n  /**\n   * Find a single file (convenience method)\n   */\n  static async findFile(\n    directory: string,\n    searchName: string,\n    options?: FileSearchOptions\n  ): Promise<string | null> {\n    const files = await this.findFiles(directory, searchName, {\n      ...options,\n      maxResults: 1\n    });\n    return files.length > 0 ? files[0] : null;\n  }\n}"]}