@dollhousemcp/mcp-server 1.3.0

package/dist/cache/APICache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * API caching implementation for reducing redundant network requests
+ */
+export declare class APICache {
+    private cache;
+    /**
+     * Retrieve cached data if still valid
+     */
+    get(key: string): any | null;
+    /**
+     * Cache data with current timestamp
+     */
+    set(key: string, data: any): void;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Get current cache size
+     */
+    size(): number;
+}
+//# sourceMappingURL=APICache.d.ts.map

package/dist/cache/APICache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APICache.d.ts","sourceRoot":"","sources":["../../src/cache/APICache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,qBAAa,QAAQ;IACnB,OAAO,CAAC,KAAK,CAAiC;IAE9C;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI;IAY5B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAOjC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,MAAM;CAGf"}

package/dist/cache/APICache.js

@@ -0,0 +1,42 @@
+/**
+ * API caching implementation for reducing redundant network requests
+ */
+import { SECURITY_LIMITS } from '../security/constants.js';
+export class APICache {
+    cache = new Map();
+    /**
+     * Retrieve cached data if still valid
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() - entry.timestamp > SECURITY_LIMITS.CACHE_TTL_MS) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    /**
+     * Cache data with current timestamp
+     */
+    set(key, data) {
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Clear all cached entries
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get current cache size
+     */
+    size() {
+        return this.cache.size;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQVBJQ2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2FjaGUvQVBJQ2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFHM0QsTUFBTSxPQUFPLFFBQVE7SUFDWCxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBQXNCLENBQUM7SUFFOUM7O09BRUc7SUFDSCxHQUFHLENBQUMsR0FBVztRQUNiLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2xDLElBQUksQ0FBQyxLQUFLO1lBQUUsT0FBTyxJQUFJLENBQUM7UUFFeEIsSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsS0FBSyxDQUFDLFNBQVMsR0FBRyxlQUFlLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDaEUsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDdkIsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBRUQsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDO0lBQ3BCLENBQUM7SUFFRDs7T0FFRztJQUNILEdBQUcsQ0FBQyxHQUFXLEVBQUUsSUFBUztRQUN4QixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUU7WUFDbEIsSUFBSTtZQUNKLFNBQVMsRUFBRSxJQUFJLENBQUMsR0FBRyxFQUFFO1NBQ3RCLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRDs7T0FFRztJQUNILEtBQUs7UUFDSCxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUk7UUFDRixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO0lBQ3pCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQVBJIGNhY2hpbmcgaW1wbGVtZW50YXRpb24gZm9yIHJlZHVjaW5nIHJlZHVuZGFudCBuZXR3b3JrIHJlcXVlc3RzXG4gKi9cblxuaW1wb3J0IHsgU0VDVVJJVFlfTElNSVRTIH0gZnJvbSAnLi4vc2VjdXJpdHkvY29uc3RhbnRzLmpzJztcbmltcG9ydCB7IENhY2hlRW50cnkgfSBmcm9tICcuLi90eXBlcy9jYWNoZS5qcyc7XG5cbmV4cG9ydCBjbGFzcyBBUElDYWNoZSB7XG4gIHByaXZhdGUgY2FjaGUgPSBuZXcgTWFwPHN0cmluZywgQ2FjaGVFbnRyeT4oKTtcbiAgXG4gIC8qKlxuICAgKiBSZXRyaWV2ZSBjYWNoZWQgZGF0YSBpZiBzdGlsbCB2YWxpZFxuICAgKi9cbiAgZ2V0KGtleTogc3RyaW5nKTogYW55IHwgbnVsbCB7XG4gICAgY29uc3QgZW50cnkgPSB0aGlzLmNhY2hlLmdldChrZXkpO1xuICAgIGlmICghZW50cnkpIHJldHVybiBudWxsO1xuICAgIFxuICAgIGlmIChEYXRlLm5vdygpIC0gZW50cnkudGltZXN0YW1wID4gU0VDVVJJVFlfTElNSVRTLkNBQ0hFX1RUTF9NUykge1xuICAgICAgdGhpcy5jYWNoZS5kZWxldGUoa2V5KTtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgICBcbiAgICByZXR1cm4gZW50cnkuZGF0YTtcbiAgfVxuICBcbiAgLyoqXG4gICAqIENhY2hlIGRhdGEgd2l0aCBjdXJyZW50IHRpbWVzdGFtcFxuICAgKi9cbiAgc2V0KGtleTogc3RyaW5nLCBkYXRhOiBhbnkpOiB2b2lkIHtcbiAgICB0aGlzLmNhY2hlLnNldChrZXksIHtcbiAgICAgIGRhdGEsXG4gICAgICB0aW1lc3RhbXA6IERhdGUubm93KClcbiAgICB9KTtcbiAgfVxuICBcbiAgLyoqXG4gICAqIENsZWFyIGFsbCBjYWNoZWQgZW50cmllc1xuICAgKi9cbiAgY2xlYXIoKTogdm9pZCB7XG4gICAgdGhpcy5jYWNoZS5jbGVhcigpO1xuICB9XG4gIFxuICAvKipcbiAgICogR2V0IGN1cnJlbnQgY2FjaGUgc2l6ZVxuICAgKi9cbiAgc2l6ZSgpOiBudW1iZXIge1xuICAgIHJldHVybiB0aGlzLmNhY2hlLnNpemU7XG4gIH1cbn0iXX0=

package/dist/cache/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cache module exports
+ */
+export * from './APICache.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,eAAe,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,5 @@
+/**
+ * Cache module exports
+ */
+export * from './APICache.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2FjaGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ2FjaGUgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL0FQSUNhY2hlLmpzJzsiXX0=

package/dist/collection/CollectionBrowser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browse collection content from GitHub
+ */
+import { GitHubClient } from './GitHubClient.js';
+export declare class CollectionBrowser {
+    private githubClient;
+    private baseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Browse collection content by section and type
+     * @param section - Top level section: library, showcase, or catalog
+     * @param type - Optional content type within the library section (personas, skills, etc.)
+     */
+    browseCollection(section?: string, type?: string): Promise<{
+        items: any[];
+        categories: any[];
+        sections?: any[];
+    }>;
+    /**
+     * Format collection browse results
+     */
+    formatBrowseResults(items: any[], categories: any[], section?: string, type?: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=CollectionBrowser.d.ts.map

package/dist/collection/CollectionBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionBrowser.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAItC;;;;OAIG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IA6CvH;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiF7H"}

package/dist/collection/CollectionBrowser.js

@@ -0,0 +1,120 @@
+/**
+ * Browse collection content from GitHub
+ */
+export class CollectionBrowser {
+    githubClient;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Browse collection content by section and type
+     * @param section - Top level section: library, showcase, or catalog
+     * @param type - Optional content type within the library section (personas, skills, etc.)
+     */
+    async browseCollection(section, type) {
+        let url = this.baseUrl;
+        // If no section provided, show top-level sections
+        if (!section) {
+            const data = await this.githubClient.fetchFromGitHub(url);
+            if (!Array.isArray(data)) {
+                throw new Error('Invalid collection response. Expected directory listing.');
+            }
+            // Filter to only show content directories
+            const sections = data.filter((item) => item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name));
+            return { items: [], categories: [], sections };
+        }
+        // Browse within a section
+        url = type
+            ? `${this.baseUrl}/${section}/${type}`
+            : `${this.baseUrl}/${section}`;
+        const data = await this.githubClient.fetchFromGitHub(url);
+        if (!Array.isArray(data)) {
+            throw new Error('Invalid collection response. Expected directory listing.');
+        }
+        // In the library section, we have content type directories
+        if (section === 'library' && !type) {
+            const contentTypes = data.filter((item) => item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name));
+            return { items: [], categories: contentTypes };
+        }
+        // For library content types, show files directly (flat structure)
+        const items = data.filter((item) => item.type === 'file' && item.name.endsWith('.md'));
+        // For non-library sections, they might still have subdirectories
+        const categories = section === 'library' ? [] : data.filter((item) => item.type === 'dir');
+        return { items, categories };
+    }
+    /**
+     * Format collection browse results
+     */
+    formatBrowseResults(items, categories, section, type, personaIndicator = '') {
+        const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\n\n`];
+        // Show top-level sections if no section specified
+        if (!section && categories.length > 0) {
+            textParts.push(`**📚 Collection Sections (${categories.length}):**\n`);
+            categories.forEach((sec) => {
+                const sectionIcons = {
+                    'library': '📖',
+                    'showcase': '⭐',
+                    'catalog': '💎'
+                };
+                const icon = sectionIcons[sec.name] || '📁';
+                const descriptions = {
+                    'library': 'Free community content',
+                    'showcase': 'Featured high-quality content',
+                    'catalog': 'Premium content (coming soon)'
+                };
+                textParts.push(`   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\n`, `      Browse: \`browse_collection "${sec.name}"\`\n\n`);
+            });
+            return textParts.join('');
+        }
+        // Show content types within library section
+        if (section === 'library' && !type && categories.length > 0) {
+            textParts.push(`**📖 Library Content Types (${categories.length}):**\n`);
+            categories.forEach((cat) => {
+                const typeIcons = {
+                    'personas': '🎭',
+                    'skills': '🛠️',
+                    'agents': '🤖',
+                    'prompts': '💬',
+                    'templates': '📄',
+                    'tools': '🔧',
+                    'ensembles': '🎼',
+                    'memories': '🧠'
+                };
+                const icon = typeIcons[cat.name] || '📁';
+                textParts.push(`   ${icon} **${cat.name}** - Browse: \`browse_collection "library" "${cat.name}"\`\n`);
+            });
+            textParts.push('\n');
+        }
+        else if (categories.length > 0) {
+            // Only show category navigation for non-library sections (showcase, catalog)
+            textParts.push(`**📁 Subdirectories in ${section}${type ? `/${type}` : ''} (${categories.length}):**\n`);
+            categories.forEach((cat) => {
+                const browsePath = type ? `"${section}" "${type}/${cat.name}"` : `"${section}" "${cat.name}"`;
+                textParts.push(`   📂 **${cat.name}** - Browse: \`browse_collection ${browsePath}\`\n`);
+            });
+            textParts.push('\n');
+        }
+        if (items.length > 0) {
+            const contentType = type || 'content';
+            const contentIcons = {
+                'personas': '🎭',
+                'skills': '🛠️',
+                'agents': '🤖',
+                'prompts': '💬',
+                'templates': '📄',
+                'tools': '🔧',
+                'ensembles': '🎼',
+                'memories': '🧠'
+            };
+            const icon = contentIcons[contentType] || '📄';
+            textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${type ? `/${type}` : ''} (${items.length}):**\n`);
+            items.forEach((item) => {
+                const fullPath = section + (type ? `/${type}` : '') + `/${item.name}`;
+                textParts.push(`   ▫️ **${item.name.replace('.md', '')}**\n`, `      📥 Install: \`install_content "${fullPath}"\`\n`, `      👁️ Details: \`get_collection_content "${fullPath}"\`\n\n`);
+            });
+        }
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionBrowser.js","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browse collection content from GitHub\n */\n\nimport { GitHubClient } from './GitHubClient.js';\nimport { logger } from '../utils/logger.js';\n\nexport class CollectionBrowser {\n  private githubClient: GitHubClient;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n  }\n  \n  /**\n   * Browse collection content by section and type\n   * @param section - Top level section: library, showcase, or catalog\n   * @param type - Optional content type within the library section (personas, skills, etc.)\n   */\n  async browseCollection(section?: string, type?: string): Promise<{ items: any[], categories: any[], sections?: any[] }> {\n    let url = this.baseUrl;\n    \n    // If no section provided, show top-level sections\n    if (!section) {\n      const data = await this.githubClient.fetchFromGitHub(url);\n      if (!Array.isArray(data)) {\n        throw new Error('Invalid collection response. Expected directory listing.');\n      }\n      \n      // Filter to only show content directories\n      const sections = data.filter((item: any) => \n        item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name)\n      );\n      \n      return { items: [], categories: [], sections };\n    }\n    \n    // Browse within a section\n    url = type \n      ? `${this.baseUrl}/${section}/${type}` \n      : `${this.baseUrl}/${section}`;\n    \n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (!Array.isArray(data)) {\n      throw new Error('Invalid collection response. Expected directory listing.');\n    }\n    \n    // In the library section, we have content type directories\n    if (section === 'library' && !type) {\n      const contentTypes = data.filter((item: any) => \n        item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name)\n      );\n      return { items: [], categories: contentTypes };\n    }\n    \n    // For library content types, show files directly (flat structure)\n    const items = data.filter((item: any) => item.type === 'file' && item.name.endsWith('.md'));\n    // For non-library sections, they might still have subdirectories\n    const categories = section === 'library' ? [] : data.filter((item: any) => item.type === 'dir');\n    \n    return { items, categories };\n  }\n  \n  /**\n   * Format collection browse results\n   */\n  formatBrowseResults(items: any[], categories: any[], section?: string, type?: string, personaIndicator: string = ''): string {\n    const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\\n\\n`];\n    \n    // Show top-level sections if no section specified\n    if (!section && categories.length > 0) {\n      textParts.push(`**📚 Collection Sections (${categories.length}):**\\n`);\n      categories.forEach((sec: any) => {\n        const sectionIcons: { [key: string]: string } = {\n          'library': '📖',\n          'showcase': '⭐',\n          'catalog': '💎'\n        };\n        const icon = sectionIcons[sec.name] || '📁';\n        const descriptions: { [key: string]: string } = {\n          'library': 'Free community content',\n          'showcase': 'Featured high-quality content',\n          'catalog': 'Premium content (coming soon)'\n        };\n        textParts.push(\n          `   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\\n`,\n          `      Browse: \\`browse_collection \"${sec.name}\"\\`\\n\\n`\n        );\n      });\n      return textParts.join('');\n    }\n    \n    // Show content types within library section\n    if (section === 'library' && !type && categories.length > 0) {\n      textParts.push(`**📖 Library Content Types (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const typeIcons: { [key: string]: string } = {\n          'personas': '🎭',\n          'skills': '🛠️',\n          'agents': '🤖',\n          'prompts': '💬',\n          'templates': '📄',\n          'tools': '🔧',\n          'ensembles': '🎼',\n          'memories': '🧠'\n        };\n        const icon = typeIcons[cat.name] || '📁';\n        textParts.push(`   ${icon} **${cat.name}** - Browse: \\`browse_collection \"library\" \"${cat.name}\"\\`\\n`);\n      });\n      textParts.push('\\n');\n    } else if (categories.length > 0) {\n      // Only show category navigation for non-library sections (showcase, catalog)\n      textParts.push(`**📁 Subdirectories in ${section}${type ? `/${type}` : ''} (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const browsePath = type ? `\"${section}\" \"${type}/${cat.name}\"` : `\"${section}\" \"${cat.name}\"`;\n        textParts.push(`   📂 **${cat.name}** - Browse: \\`browse_collection ${browsePath}\\`\\n`);\n      });\n      textParts.push('\\n');\n    }\n    \n    if (items.length > 0) {\n      const contentType = type || 'content';\n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'prompts': '💬',\n        'templates': '📄',\n        'tools': '🔧',\n        'ensembles': '🎼',\n        'memories': '🧠'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${type ? `/${type}` : ''} (${items.length}):**\\n`);\n      items.forEach((item: any) => {\n        const fullPath = section + (type ? `/${type}` : '') + `/${item.name}`;\n        textParts.push(\n          `   ▫️ **${item.name.replace('.md', '')}**\\n`,\n          `      📥 Install: \\`install_content \"${fullPath}\"\\`\\n`,\n          `      👁️ Details: \\`get_collection_content \"${fullPath}\"\\`\\n\\n`\n        );\n      });\n    }\n    \n    return textParts.join('');\n  }\n}"]}

package/dist/collection/CollectionSearch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Search for content in the collection
+ */
+import { GitHubClient } from './GitHubClient.js';
+export declare class CollectionSearch {
+    private githubClient;
+    private searchBaseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Search collection for content matching query
+     */
+    searchCollection(query: string): Promise<any[]>;
+    /**
+     * Format search results
+     */
+    formatSearchResults(items: any[], query: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=CollectionSearch.d.ts.map

package/dist/collection/CollectionSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionSearch.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionSearch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAwC;gBAEjD,YAAY,EAAE,YAAY;IAItC;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAYrD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiCxF"}

package/dist/collection/CollectionSearch.js

@@ -0,0 +1,48 @@
+/**
+ * Search for content in the collection
+ */
+export class CollectionSearch {
+    githubClient;
+    searchBaseUrl = 'https://api.github.com/search/code';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Search collection for content matching query
+     */
+    async searchCollection(query) {
+        const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
+        const data = await this.githubClient.fetchFromGitHub(searchUrl);
+        if (!data.items) {
+            return [];
+        }
+        return data.items;
+    }
+    /**
+     * 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,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

package/dist/collection/ElementInstaller.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Install AI customization elements from collection
+ * Supports all element types: personas, skills, templates, agents, memories, ensembles
+ */
+import { GitHubClient } from './GitHubClient.js';
+import { IElementMetadata } from '../types/elements/IElement.js';
+import { ElementType } from '../portfolio/PortfolioManager.js';
+export declare class ElementInstaller {
+    private githubClient;
+    private portfolioManager;
+    private baseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Install AI customization element from the collection
+     * Automatically detects element type from path structure
+     */
+    installContent(inputPath: string): Promise<{
+        success: boolean;
+        message: string;
+        metadata?: IElementMetadata;
+        elementType?: ElementType;
+        filename?: string;
+    }>;
+    /**
+     * Get ElementType from string
+     */
+    private getElementTypeFromString;
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata: IElementMetadata, filename: string, elementType: ElementType): string;
+}
+//# sourceMappingURL=ElementInstaller.d.ts.map

package/dist/collection/ElementInstaller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementInstaller.d.ts","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAMjE,OAAO,EAAoB,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEjF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAKtC;;;OAGG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;QAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IA+FF;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAkBhC;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;CAmBrG"}

package/dist/collection/ElementInstaller.js

@@ -0,0 +1,142 @@
+/**
+ * Install AI customization elements from collection
+ * Supports all element types: personas, skills, templates, agents, memories, ensembles
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { validatePath, validateFilename, validateContentSize } from '../security/InputValidator.js';
+import { SECURITY_LIMITS } from '../security/constants.js';
+import { ContentValidator } from '../security/contentValidator.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { SecurityError } from '../errors/SecurityError.js';
+import { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';
+export class ElementInstaller {
+    githubClient;
+    portfolioManager;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+        this.portfolioManager = PortfolioManager.getInstance();
+    }
+    /**
+     * Install AI customization element from the collection
+     * Automatically detects element type from path structure
+     */
+    async installContent(inputPath) {
+        // Validate and sanitize the input path
+        const sanitizedPath = validatePath(inputPath);
+        // Detect element type from path structure
+        // Expected format: library/[element-type]/[category]/[element].md
+        const pathParts = sanitizedPath.split('/');
+        if (pathParts.length < 3 || pathParts[0] !== 'library') {
+            throw new Error('Invalid collection path format. Expected: library/[element-type]/[category]/[element].md');
+        }
+        const elementTypeStr = pathParts[1];
+        const elementType = this.getElementTypeFromString(elementTypeStr);
+        // Ensure the path ends with .md
+        if (!sanitizedPath.endsWith('.md')) {
+            throw new Error('Invalid file type. Only .md files are allowed.');
+        }
+        const url = `${this.baseUrl}/${sanitizedPath}`;
+        const data = await this.githubClient.fetchFromGitHub(url);
+        if (data.type !== 'file') {
+            throw new Error('Path does not point to a file');
+        }
+        // Check file size before downloading
+        if (data.size > SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES) {
+            throw new Error(`File too large (${data.size} bytes, max ${SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES} bytes)`);
+        }
+        // Decode Base64 content
+        const content = Buffer.from(data.content, 'base64').toString('utf-8');
+        // Validate content size after decoding
+        validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);
+        // Sanitize content for security threats
+        const sanitizedContent = ContentValidator.sanitizePersonaContent(content);
+        // Use secure YAML parser
+        let parsed;
+        try {
+            parsed = SecureYamlParser.safeMatter(sanitizedContent);
+        }
+        catch (error) {
+            if (error instanceof SecurityError) {
+                throw new Error(`Security threat in content: ${error.message}`);
+            }
+            throw error;
+        }
+        const metadata = parsed.data;
+        // Additional metadata validation for injection attacks
+        const metadataValidation = ContentValidator.validateMetadata(metadata);
+        if (!metadataValidation.isValid) {
+            throw new Error(`Security validation failed: ${metadataValidation.detectedPatterns?.join(', ')}`);
+        }
+        // Validate metadata
+        if (!metadata.name || !metadata.description) {
+            throw new Error('Invalid content: missing required name or description');
+        }
+        // Generate and validate local filename
+        const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-element.md';
+        const filename = validateFilename(originalFilename);
+        // Get appropriate directory for element type
+        const elementDir = this.portfolioManager.getElementDir(elementType);
+        const localPath = path.join(elementDir, filename);
+        // Check if file already exists
+        try {
+            await fs.access(localPath);
+            return {
+                success: false,
+                message: `AI customization element already exists: ${filename}\n\nThe element has already been installed.`
+            };
+        }
+        catch {
+            // File doesn't exist, proceed with installation
+        }
+        // Write the sanitized file
+        await fs.writeFile(localPath, sanitizedContent, 'utf-8');
+        return {
+            success: true,
+            message: `AI customization element installed successfully!`,
+            metadata,
+            filename,
+            elementType
+        };
+    }
+    /**
+     * Get ElementType from string
+     */
+    getElementTypeFromString(typeStr) {
+        const typeMap = {
+            'personas': ElementType.PERSONA,
+            'skills': ElementType.SKILL,
+            'templates': ElementType.TEMPLATE,
+            'agents': ElementType.AGENT,
+            'memories': ElementType.MEMORY,
+            'ensembles': ElementType.ENSEMBLE
+        };
+        const elementType = typeMap[typeStr];
+        if (!elementType) {
+            throw new Error(`Unknown element type: ${typeStr}. Valid types: ${Object.keys(typeMap).join(', ')}`);
+        }
+        return elementType;
+    }
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata, filename, elementType) {
+        const typeEmojis = {
+            [ElementType.PERSONA]: '🎭',
+            [ElementType.SKILL]: '🎯',
+            [ElementType.TEMPLATE]: '📄',
+            [ElementType.AGENT]: '🤖',
+            [ElementType.MEMORY]: '🧠',
+            [ElementType.ENSEMBLE]: '🎼'
+        };
+        const emoji = typeEmojis[elementType] || '📦';
+        const typeName = elementType.charAt(0).toUpperCase() + elementType.slice(1);
+        return `✅ **AI Customization Element Installed Successfully!**\n\n` +
+            `${emoji} **${metadata.name}** ${metadata.author ? `by ${metadata.author}` : ''}\n` +
+            `📁 Type: ${typeName}\n` +
+            `📄 Saved as: ${filename}\n\n` +
+            `🚀 **Ready to use!**`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementInstaller.js","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install AI customization elements from collection\n * Supports all element types: personas, skills, templates, agents, memories, ensembles\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { GitHubClient } from './GitHubClient.js';\nimport { IElementMetadata } from '../types/elements/IElement.js';\nimport { validatePath, validateFilename, validateContentSize } from '../security/InputValidator.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { ContentValidator } from '../security/contentValidator.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';\n\nexport class ElementInstaller {\n  private githubClient: GitHubClient;\n  private portfolioManager: PortfolioManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n    this.portfolioManager = PortfolioManager.getInstance();\n  }\n  \n  /**\n   * Install AI customization element from the collection\n   * Automatically detects element type from path structure\n   */\n  async installContent(inputPath: string): Promise<{ \n    success: boolean; \n    message: string;\n    metadata?: IElementMetadata;\n    elementType?: ElementType;\n    filename?: string;\n  }> {\n    // Validate and sanitize the input path\n    const sanitizedPath = validatePath(inputPath);\n    \n    // Detect element type from path structure\n    // Expected format: library/[element-type]/[category]/[element].md\n    const pathParts = sanitizedPath.split('/');\n    if (pathParts.length < 3 || pathParts[0] !== 'library') {\n      throw new Error('Invalid collection path format. Expected: library/[element-type]/[category]/[element].md');\n    }\n    \n    const elementTypeStr = pathParts[1];\n    const elementType = this.getElementTypeFromString(elementTypeStr);\n    \n    // Ensure the path ends with .md\n    if (!sanitizedPath.endsWith('.md')) {\n      throw new Error('Invalid file type. Only .md files are allowed.');\n    }\n    \n    const url = `${this.baseUrl}/${sanitizedPath}`;\n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (data.type !== 'file') {\n      throw new Error('Path does not point to a file');\n    }\n    \n    // Check file size before downloading\n    if (data.size > SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES) {\n      throw new Error(`File too large (${data.size} bytes, max ${SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES} bytes)`);\n    }\n    \n    // Decode Base64 content\n    const content = Buffer.from(data.content, 'base64').toString('utf-8');\n    \n    // Validate content size after decoding\n    validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);\n    \n    // Sanitize content for security threats\n    const sanitizedContent = ContentValidator.sanitizePersonaContent(content);\n    \n    // Use secure YAML parser\n    let parsed;\n    try {\n      parsed = SecureYamlParser.safeMatter(sanitizedContent);\n    } catch (error) {\n      if (error instanceof SecurityError) {\n        throw new Error(`Security threat in content: ${error.message}`);\n      }\n      throw error;\n    }\n    \n    const metadata = parsed.data as IElementMetadata;\n    \n    // Additional metadata validation for injection attacks\n    const metadataValidation = ContentValidator.validateMetadata(metadata);\n    if (!metadataValidation.isValid) {\n      throw new Error(`Security validation failed: ${metadataValidation.detectedPatterns?.join(', ')}`);\n    }\n    \n    // Validate metadata\n    if (!metadata.name || !metadata.description) {\n      throw new Error('Invalid content: missing required name or description');\n    }\n    \n    // Generate and validate local filename\n    const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-element.md';\n    const filename = validateFilename(originalFilename);\n    \n    // Get appropriate directory for element type\n    const elementDir = this.portfolioManager.getElementDir(elementType);\n    const localPath = path.join(elementDir, filename);\n    \n    // Check if file already exists\n    try {\n      await fs.access(localPath);\n      return {\n        success: false,\n        message: `AI customization element already exists: ${filename}\\n\\nThe element has already been installed.`\n      };\n    } catch {\n      // File doesn't exist, proceed with installation\n    }\n    \n    // Write the sanitized file\n    await fs.writeFile(localPath, sanitizedContent, 'utf-8');\n    \n    return {\n      success: true,\n      message: `AI customization element installed successfully!`,\n      metadata,\n      filename,\n      elementType\n    };\n  }\n  \n  /**\n   * Get ElementType from string\n   */\n  private getElementTypeFromString(typeStr: string): ElementType {\n    const typeMap: Record<string, ElementType> = {\n      'personas': ElementType.PERSONA,\n      'skills': ElementType.SKILL,\n      'templates': ElementType.TEMPLATE,\n      'agents': ElementType.AGENT,\n      'memories': ElementType.MEMORY,\n      'ensembles': ElementType.ENSEMBLE\n    };\n    \n    const elementType = typeMap[typeStr];\n    if (!elementType) {\n      throw new Error(`Unknown element type: ${typeStr}. Valid types: ${Object.keys(typeMap).join(', ')}`);\n    }\n    \n    return elementType;\n  }\n  \n  /**\n   * Format installation success message\n   */\n  formatInstallSuccess(metadata: IElementMetadata, filename: string, elementType: ElementType): string {\n    const typeEmojis: Record<ElementType, string> = {\n      [ElementType.PERSONA]: '🎭',\n      [ElementType.SKILL]: '🎯',\n      [ElementType.TEMPLATE]: '📄',\n      [ElementType.AGENT]: '🤖',\n      [ElementType.MEMORY]: '🧠',\n      [ElementType.ENSEMBLE]: '🎼'\n    };\n    \n    const emoji = typeEmojis[elementType] || '📦';\n    const typeName = elementType.charAt(0).toUpperCase() + elementType.slice(1);\n    \n    return `✅ **AI Customization Element Installed Successfully!**\\n\\n` +\n      `${emoji} **${metadata.name}** ${metadata.author ? `by ${metadata.author}` : ''}\\n` +\n      `📁 Type: ${typeName}\\n` +\n      `📄 Saved as: ${filename}\\n\\n` +\n      `🚀 **Ready to use!**`;\n  }\n}"]}

package/dist/collection/GitHubClient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GitHub API client for collection integration
+ */
+import { APICache } from '../cache/APICache.js';
+export declare class GitHubClient {
+    private apiCache;
+    private rateLimitTracker;
+    constructor(apiCache: APICache, rateLimitTracker: Map<string, number[]>);
+    /**
+     * Check rate limit for API calls
+     */
+    private checkRateLimit;
+    /**
+     * Fetch data from GitHub API with caching and rate limiting
+     */
+    fetchFromGitHub(url: string, requireAuth?: boolean): Promise<any>;
+    /**
+     * Validate token permissions for collection operations
+     */
+    validateCollectionPermissions(): Promise<void>;
+}
+//# sourceMappingURL=GitHubClient.d.ts.map

package/dist/collection/GitHubClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubClient.d.ts","sourceRoot":"","sources":["../../src/collection/GitHubClient.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,gBAAgB,CAAwB;gBAEpC,QAAQ,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAKvE;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACG,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,GAAE,OAAe,GAAG,OAAO,CAAC,GAAG,CAAC;IAyF9E;;OAEG;IACG,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC;CASrD"}