@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.
152 lines • 21.4 kB
JavaScript
/**
* Search for content in the collection
*/
import { CollectionCache } from '../cache/CollectionCache.js';
import { CollectionSeeder } from './CollectionSeeder.js';
import { logger } from '../utils/logger.js';
import { normalizeSearchTerm, validateSearchQuery } from '../utils/searchUtils.js';
export class CollectionSearch {
githubClient;
collectionCache;
searchBaseUrl = 'https://api.github.com/search/code';
constructor(githubClient, collectionCache) {
this.githubClient = githubClient;
this.collectionCache = collectionCache || new CollectionCache();
}
/**
* Search collection for content matching query
* Falls back to cached data when GitHub API is not available or not authenticated
*/
async searchCollection(query) {
// Validate search query for security
try {
validateSearchQuery(query, 1000);
}
catch (error) {
logger.warn(`Invalid search query: ${error}`);
return [];
}
try {
// First, try GitHub API search if authenticated
const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
const data = await this.githubClient.fetchFromGitHub(searchUrl, false); // Don't require auth for search
if (data.items && Array.isArray(data.items)) {
logger.debug(`Found ${data.items.length} items via GitHub API search`);
// Update cache with fresh data from API
await this.updateCacheFromGitHubItems(data.items);
return data.items;
}
return [];
}
catch (error) {
logger.debug(`GitHub API search failed, falling back to cache: ${error}`);
// Fallback to cached search
return this.searchFromCache(query);
}
}
/**
* Search cached collection items
*/
async searchFromCache(query) {
try {
// Try to load from cache first
const cachedItems = await this.collectionCache.searchCache(query);
if (cachedItems.length > 0) {
logger.debug(`Found ${cachedItems.length} items from cache`);
return this.convertCacheItemsToGitHubFormat(cachedItems);
}
// If cache is empty or no results, use seed data
const seedItems = this.searchSeedData(query);
if (seedItems.length > 0) {
logger.debug(`Found ${seedItems.length} items from seed data`);
// Save seed data to cache for future use
await this.collectionCache.saveCache(CollectionSeeder.getSeedData());
return this.convertCacheItemsToGitHubFormat(seedItems);
}
logger.debug('No items found in cache or seed data');
return [];
}
catch (error) {
logger.error(`Cache search failed: ${error}`);
// Last resort: search seed data without cache
const seedItems = this.searchSeedData(query);
logger.debug(`Fallback to seed data found ${seedItems.length} items`);
return this.convertCacheItemsToGitHubFormat(seedItems);
}
}
/**
* Search seed data for matching items with fuzzy matching
*/
searchSeedData(query) {
const seedData = CollectionSeeder.getSeedData();
const normalizedQuery = normalizeSearchTerm(query);
return seedData.filter(item => {
const normalizedName = normalizeSearchTerm(item.name);
const normalizedPath = normalizeSearchTerm(item.path);
return normalizedName.includes(normalizedQuery) ||
normalizedPath.includes(normalizedQuery);
});
}
/**
* Convert cache items to GitHub API format for consistent response structure
*/
convertCacheItemsToGitHubFormat(cacheItems) {
return cacheItems.map(item => ({
name: item.name,
path: item.path,
sha: item.sha,
url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,
html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`,
repository: {
name: 'collection',
full_name: 'DollhouseMCP/collection'
}
}));
}
/**
* Update cache with fresh data from GitHub API items
*/
async updateCacheFromGitHubItems(githubItems) {
try {
const cacheItems = githubItems.map(item => ({
name: item.name,
path: item.path,
sha: item.sha,
last_modified: new Date().toISOString()
}));
await this.collectionCache.saveCache(cacheItems);
logger.debug(`Updated cache with ${cacheItems.length} items from GitHub API`);
}
catch (error) {
logger.debug(`Failed to update cache: ${error}`);
// Don't throw - cache update failures shouldn't break functionality
}
}
/**
* Format search results
*/
formatSearchResults(items, query, personaIndicator = '') {
if (items.length === 0) {
return `${personaIndicator}🔍 No content found for query: "${query}"`;
}
const textParts = [`${personaIndicator}🔍 **Search Results for "${query}"** (${items.length} found)\n\n`];
items.forEach((item) => {
// Extract content type from path (library/personas/creative/writer.md -> personas)
const pathParts = item.path.split('/');
const contentType = pathParts[1] || 'content';
const contentIcons = {
'personas': '🎭',
'skills': '🛠️',
'agents': '🤖',
'prompts': '💬',
'templates': '📄',
'tools': '🔧',
'ensembles': '🎼'
};
const icon = contentIcons[contentType] || '📄';
textParts.push(` ${icon} **${item.name.replace('.md', '')}**\n`, ` 📂 Path: ${item.path}\n`, ` 📥 Install: \`install_content "${item.path}"\`\n`, ` 👁️ Details: \`get_collection_content "${item.path}"\`\n\n`);
});
return textParts.join('');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionSearch.js","sourceRoot":"","sources":["../../src/collection/CollectionSearch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Search for content in the collection\n */\n\nimport { GitHubClient } from './GitHubClient.js';\nimport { CollectionCache, CollectionItem } from '../cache/CollectionCache.js';\nimport { CollectionSeeder } from './CollectionSeeder.js';\nimport { logger } from '../utils/logger.js';\nimport { normalizeSearchTerm, validateSearchQuery } from '../utils/searchUtils.js';\n\nexport class CollectionSearch {\n  private githubClient: GitHubClient;\n  private collectionCache: CollectionCache;\n  private searchBaseUrl = 'https://api.github.com/search/code';\n  \n  constructor(githubClient: GitHubClient, collectionCache?: CollectionCache) {\n    this.githubClient = githubClient;\n    this.collectionCache = collectionCache || new CollectionCache();\n  }\n  \n  /**\n   * Search collection for content matching query\n   * Falls back to cached data when GitHub API is not available or not authenticated\n   */\n  async searchCollection(query: string): Promise<any[]> {\n    // Validate search query for security\n    try {\n      validateSearchQuery(query, 1000);\n    } catch (error) {\n      logger.warn(`Invalid search query: ${error}`);\n      return [];\n    }\n    \n    try {\n      // First, try GitHub API search if authenticated\n      const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;\n      const data = await this.githubClient.fetchFromGitHub(searchUrl, false); // Don't require auth for search\n      \n      if (data.items && Array.isArray(data.items)) {\n        logger.debug(`Found ${data.items.length} items via GitHub API search`);\n        \n        // Update cache with fresh data from API\n        await this.updateCacheFromGitHubItems(data.items);\n        \n        return data.items;\n      }\n      \n      return [];\n    } catch (error) {\n      logger.debug(`GitHub API search failed, falling back to cache: ${error}`);\n      \n      // Fallback to cached search\n      return this.searchFromCache(query);\n    }\n  }\n  \n  /**\n   * Search cached collection items\n   */\n  private async searchFromCache(query: string): Promise<any[]> {\n    try {\n      // Try to load from cache first\n      const cachedItems = await this.collectionCache.searchCache(query);\n      \n      if (cachedItems.length > 0) {\n        logger.debug(`Found ${cachedItems.length} items from cache`);\n        return this.convertCacheItemsToGitHubFormat(cachedItems);\n      }\n      \n      // If cache is empty or no results, use seed data\n      const seedItems = this.searchSeedData(query);\n      if (seedItems.length > 0) {\n        logger.debug(`Found ${seedItems.length} items from seed data`);\n        // Save seed data to cache for future use\n        await this.collectionCache.saveCache(CollectionSeeder.getSeedData());\n        return this.convertCacheItemsToGitHubFormat(seedItems);\n      }\n      \n      logger.debug('No items found in cache or seed data');\n      return [];\n    } catch (error) {\n      logger.error(`Cache search failed: ${error}`);\n      \n      // Last resort: search seed data without cache\n      const seedItems = this.searchSeedData(query);\n      logger.debug(`Fallback to seed data found ${seedItems.length} items`);\n      return this.convertCacheItemsToGitHubFormat(seedItems);\n    }\n  }\n  \n  /**\n   * Search seed data for matching items with fuzzy matching\n   */\n  private searchSeedData(query: string): CollectionItem[] {\n    const seedData = CollectionSeeder.getSeedData();\n    const normalizedQuery = normalizeSearchTerm(query);\n    \n    return seedData.filter(item => {\n      const normalizedName = normalizeSearchTerm(item.name);\n      const normalizedPath = normalizeSearchTerm(item.path);\n      \n      return normalizedName.includes(normalizedQuery) || \n             normalizedPath.includes(normalizedQuery);\n    });\n  }\n  \n  \n  /**\n   * Convert cache items to GitHub API format for consistent response structure\n   */\n  private convertCacheItemsToGitHubFormat(cacheItems: CollectionItem[]): any[] {\n    return cacheItems.map(item => ({\n      name: item.name,\n      path: item.path,\n      sha: item.sha,\n      url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,\n      html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`,\n      repository: {\n        name: 'collection',\n        full_name: 'DollhouseMCP/collection'\n      }\n    }));\n  }\n  \n  /**\n   * Update cache with fresh data from GitHub API items\n   */\n  private async updateCacheFromGitHubItems(githubItems: any[]): Promise<void> {\n    try {\n      const cacheItems: CollectionItem[] = githubItems.map(item => ({\n        name: item.name,\n        path: item.path,\n        sha: item.sha,\n        last_modified: new Date().toISOString()\n      }));\n      \n      await this.collectionCache.saveCache(cacheItems);\n      logger.debug(`Updated cache with ${cacheItems.length} items from GitHub API`);\n    } catch (error) {\n      logger.debug(`Failed to update cache: ${error}`);\n      // Don't throw - cache update failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Format search results\n   */\n  formatSearchResults(items: any[], query: string, personaIndicator: string = ''): string {\n    if (items.length === 0) {\n      return `${personaIndicator}🔍 No content found for query: \"${query}\"`;\n    }\n    \n    const textParts = [`${personaIndicator}🔍 **Search Results for \"${query}\"** (${items.length} found)\\n\\n`];\n    \n    items.forEach((item: any) => {\n      // Extract content type from path (library/personas/creative/writer.md -> personas)\n      const pathParts = item.path.split('/');\n      const contentType = pathParts[1] || 'content';\n      \n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'prompts': '💬',\n        'templates': '📄',\n        'tools': '🔧',\n        'ensembles': '🎼'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(\n        `   ${icon} **${item.name.replace('.md', '')}**\\n`,\n        `      📂 Path: ${item.path}\\n`,\n        `      📥 Install: \\`install_content \"${item.path}\"\\`\\n`,\n        `      👁️ Details: \\`get_collection_content \"${item.path}\"\\`\\n\\n`\n      );\n    });\n    \n    return textParts.join('');\n  }\n}"]}