@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/collection/PersonaInstaller.js

@@ -0,0 +1,103 @@
+/**
+ * Install content from collection
+ */
+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 PersonaInstaller {
+    githubClient;
+    personasDir;
+    portfolioManager;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient, personasDir) {
+        this.githubClient = githubClient;
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.personasDir = personasDir || this.portfolioManager.getElementDir(ElementType.PERSONA);
+    }
+    /**
+     * Install content from the collection
+     */
+    async installContent(inputPath) {
+        // Validate and sanitize the input path
+        const sanitizedPath = validatePath(inputPath);
+        // 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-persona.md';
+        const filename = validateFilename(originalFilename);
+        const localPath = path.join(this.personasDir, filename);
+        // Check if file already exists
+        try {
+            await fs.access(localPath);
+            return {
+                success: false,
+                message: `Content already exists: ${filename}\n\nUse \`reload_personas\` to refresh if you've updated it manually.`
+            };
+        }
+        catch {
+            // File doesn't exist, proceed with installation
+        }
+        // Write the sanitized file
+        await fs.writeFile(localPath, sanitizedContent, 'utf-8');
+        return {
+            success: true,
+            message: `Content installed successfully!`,
+            metadata,
+            filename
+        };
+    }
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata, filename, totalPersonas, personaIndicator = '') {
+        return `${personaIndicator}✅ **Content Installed Successfully!**\n\n` +
+            `🎭 **${metadata.name}** by ${metadata.author}\n` +
+            `📁 Saved as: ${filename}\n` +
+            `📊 Total personas: ${totalPersonas}\n\n` +
+            `🎯 **Ready to use:** \`activate_persona "${metadata.name}"\``;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaInstaller.js","sourceRoot":"","sources":["../../../../src/collection/PersonaInstaller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install content from collection\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport matter from 'gray-matter';\nimport { GitHubClient } from './GitHubClient.js';\nimport { PersonaMetadata } from '../types/persona.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 PersonaInstaller {\n  private githubClient: GitHubClient;\n  private personasDir: string;\n  private portfolioManager: PortfolioManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient, personasDir?: string) {\n    this.githubClient = githubClient;\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.personasDir = personasDir || this.portfolioManager.getElementDir(ElementType.PERSONA);\n  }\n  \n  /**\n   * Install content from the collection\n   */\n  async installContent(inputPath: string): Promise<{ \n    success: boolean; \n    message: string;\n    metadata?: PersonaMetadata;\n    filename?: string;\n  }> {\n    // Validate and sanitize the input path\n    const sanitizedPath = validatePath(inputPath);\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 PersonaMetadata;\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-persona.md';\n    const filename = validateFilename(originalFilename);\n    const localPath = path.join(this.personasDir, filename);\n    \n    // Check if file already exists\n    try {\n      await fs.access(localPath);\n      return {\n        success: false,\n        message: `Content already exists: ${filename}\\n\\nUse \\`reload_personas\\` to refresh if you've updated it manually.`\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: `Content installed successfully!`,\n      metadata,\n      filename\n    };\n  }\n  \n  /**\n   * Format installation success message\n   */\n  formatInstallSuccess(metadata: PersonaMetadata, filename: string, totalPersonas: number, personaIndicator: string = ''): string {\n    return `${personaIndicator}✅ **Content Installed Successfully!**\\n\\n` +\n      `🎭 **${metadata.name}** by ${metadata.author}\\n` +\n      `📁 Saved as: ${filename}\\n` +\n      `📊 Total personas: ${totalPersonas}\\n\\n` +\n      `🎯 **Ready to use:** \\`activate_persona \"${metadata.name}\"\\``;\n  }\n}"]}

package/dist/test/src/collection/PersonaSubmitter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Submit personas to the collection
+ */
+import { Persona } from '../types/persona.js';
+export declare class PersonaSubmitter {
+    /**
+     * Generate GitHub issue for persona submission
+     */
+    generateSubmissionIssue(persona: Persona): {
+        issueTitle: string;
+        issueBody: string;
+        githubIssueUrl: string;
+    };
+    /**
+     * Format submission response
+     */
+    formatSubmissionResponse(persona: Persona, githubIssueUrl: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=PersonaSubmitter.d.ts.map

package/dist/test/src/collection/PersonaSubmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaSubmitter.d.ts","sourceRoot":"","sources":["../../../../src/collection/PersonaSubmitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG;QACzC,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAA;KACvB;IAqCD;;OAEG;IACH,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAW1G"}

package/dist/test/src/collection/PersonaSubmitter.js

@@ -0,0 +1,57 @@
+/**
+ * Submit personas to the collection
+ */
+export class PersonaSubmitter {
+    /**
+     * Generate GitHub issue for persona submission
+     */
+    generateSubmissionIssue(persona) {
+        const issueTitle = `New Persona Submission: ${persona.metadata.name}`;
+        const issueBody = `## Persona Submission
+
+**Name:** ${persona.metadata.name}
+**Author:** ${persona.metadata.author || 'Unknown'}
+**Category:** ${persona.metadata.category || 'General'}
+**Description:** ${persona.metadata.description}
+
+### Persona Content:
+\`\`\`markdown
+---
+${Object.entries(persona.metadata)
+            .map(([key, value]) => `${key}: ${Array.isArray(value) ? JSON.stringify(value) : JSON.stringify(value)}`)
+            .join('\n')}
+---
+
+${persona.content}
+\`\`\`
+
+### Submission Details:
+- Submitted via DollhouseMCP client
+- Filename: ${persona.filename}
+- Unique ID: ${persona.unique_id}
+
+---
+*Please review this persona for inclusion in the collection.*`;
+        const githubIssueUrl = `https://github.com/DollhouseMCP/collection/issues/new?title=${encodeURIComponent(issueTitle)}&body=${encodeURIComponent(issueBody)}`;
+        return {
+            issueTitle,
+            issueBody,
+            githubIssueUrl
+        };
+    }
+    /**
+     * Format submission response
+     */
+    formatSubmissionResponse(persona, githubIssueUrl, personaIndicator = '') {
+        return `${personaIndicator}📤 **Persona Submission Prepared**\n\n` +
+            `🎭 **${persona.metadata.name}** is ready for collection submission!\n\n` +
+            `**Next Steps:**\n` +
+            `1. Click this link to create a GitHub issue: \n` +
+            `   ${githubIssueUrl}\n\n` +
+            `2. Review the pre-filled content\n` +
+            `3. Click "Submit new issue"\n` +
+            `4. The maintainers will review your submission\n\n` +
+            `⭐ **Tip:** You can also submit via pull request if you're familiar with Git!`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/collection/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Collection module exports
+ */
+export * from './GitHubClient.js';
+export * from './CollectionBrowser.js';
+export * from './CollectionSearch.js';
+export * from './PersonaDetails.js';
+export * from './PersonaInstaller.js';
+export * from './PersonaSubmitter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/collection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/collection/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/dist/test/src/collection/index.js

@@ -0,0 +1,10 @@
+/**
+ * Collection module exports
+ */
+export * from './GitHubClient.js';
+export * from './CollectionBrowser.js';
+export * from './CollectionSearch.js';
+export * from './PersonaDetails.js';
+export * from './PersonaInstaller.js';
+export * from './PersonaSubmitter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29sbGVjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb2xsZWN0aW9uIG1vZHVsZSBleHBvcnRzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9HaXRIdWJDbGllbnQuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9Db2xsZWN0aW9uQnJvd3Nlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb25TZWFyY2guanMnO1xuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hRGV0YWlscy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL1BlcnNvbmFJbnN0YWxsZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hU3VibWl0dGVyLmpzJzsiXX0=

package/dist/test/src/config/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Application-wide constants and configuration
+ */
+export declare const REPO_OWNER = "DollhouseMCP";
+export declare const REPO_NAME = "mcp-server";
+export declare const REPO_URL = "https://github.com/DollhouseMCP/mcp-server";
+export declare const RELEASES_API_URL = "https://api.github.com/repos/DollhouseMCP/mcp-server/releases/latest";
+export declare const MARKETPLACE_REPO_OWNER = "DollhouseMCP";
+export declare const MARKETPLACE_REPO_NAME = "personas";
+export declare const DEPENDENCY_REQUIREMENTS: {
+    git: {
+        minimum: string;
+        maximum: string;
+        recommended: string;
+    };
+    npm: {
+        minimum: string;
+        maximum: string;
+        recommended: string;
+    };
+};
+export declare const ADJECTIVES: string[];
+export declare const ANIMALS: string[];
+export declare const VALID_CATEGORIES: string[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/test/src/config/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/config/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AACzC,eAAO,MAAM,SAAS,eAAe,CAAC;AACtC,eAAO,MAAM,QAAQ,+CAAkD,CAAC;AACxE,eAAO,MAAM,gBAAgB,yEAA4E,CAAC;AAG1G,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AACrD,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAGhD,eAAO,MAAM,uBAAuB;;;;;;;;;;;CAWnC,CAAC;AAGF,eAAO,MAAM,UAAU,UAA0F,CAAC;AAClH,eAAO,MAAM,OAAO,UAAkF,CAAC;AAGvG,eAAO,MAAM,gBAAgB,UAAoE,CAAC"}

package/dist/test/src/config/constants.js

@@ -0,0 +1,30 @@
+/**
+ * Application-wide constants and configuration
+ */
+// Repository configuration
+export const REPO_OWNER = 'DollhouseMCP';
+export const REPO_NAME = 'mcp-server';
+export const REPO_URL = `https://github.com/${REPO_OWNER}/${REPO_NAME}`;
+export const RELEASES_API_URL = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest`;
+// Marketplace repository configuration
+export const MARKETPLACE_REPO_OWNER = 'DollhouseMCP';
+export const MARKETPLACE_REPO_NAME = 'personas';
+// Dependency version requirements
+export const DEPENDENCY_REQUIREMENTS = {
+    git: {
+        minimum: '2.20.0', // Required for modern features and security
+        maximum: '2.50.0', // Latest tested working version
+        recommended: '2.40.0' // Optimal version for stability
+    },
+    npm: {
+        minimum: '8.0.0', // Required for package-lock v2 and modern features  
+        maximum: '12.0.0', // Latest tested working version
+        recommended: '10.0.0' // Optimal version for stability
+    }
+};
+// Anonymous ID generation
+export const ADJECTIVES = ['clever', 'swift', 'bright', 'bold', 'wise', 'calm', 'keen', 'witty', 'sharp', 'cool'];
+export const ANIMALS = ['fox', 'owl', 'cat', 'wolf', 'bear', 'hawk', 'deer', 'lion', 'eagle', 'tiger'];
+// Valid persona categories
+export const VALID_CATEGORIES = ['creative', 'professional', 'educational', 'gaming', 'personal'];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/config/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Central export point for configuration
+ */
+export * from './constants.js';
+export * from './indicator-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/config/index.d.ts.map

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

package/dist/test/src/config/index.js

@@ -0,0 +1,6 @@
+/**
+ * Central export point for configuration
+ */
+export * from './constants.js';
+export * from './indicator-config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29uZmlnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDZW50cmFsIGV4cG9ydCBwb2ludCBmb3IgY29uZmlndXJhdGlvblxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaW5kaWNhdG9yLWNvbmZpZy5qcyc7Il19

package/dist/test/src/config/indicator-config.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Configuration interface for the persona active indicator system.
+ * Controls how persona information is displayed in AI responses.
+ *
+ * @interface IndicatorConfig
+ * @example
+ * ```typescript
+ * const config: IndicatorConfig = {
+ *   enabled: true,
+ *   style: 'full',
+ *   showEmoji: true,
+ *   showName: true,
+ *   showVersion: true,
+ *   showAuthor: true,
+ *   showCategory: false,
+ *   separator: ' | ',
+ *   emoji: '🎭',
+ *   bracketStyle: 'square'
+ * };
+ * ```
+ */
+export interface IndicatorConfig {
+    /** Whether to show the indicator at all */
+    enabled: boolean;
+    /** Format style: 'full', 'minimal', 'compact', 'custom' */
+    style: 'full' | 'minimal' | 'compact' | 'custom';
+    /**
+     * Custom format template (used when style is 'custom')
+     * Available placeholders: {emoji}, {name}, {version}, {author}, {category}
+     */
+    customFormat?: string;
+    /** Whether to include specific elements */
+    showEmoji: boolean;
+    showName: boolean;
+    showVersion: boolean;
+    showAuthor: boolean;
+    showCategory: boolean;
+    /** Separator between indicator and response */
+    separator: string;
+    /** Emoji to use (defaults to 🎭) */
+    emoji: string;
+    /** Bracket style: 'square', 'round', 'curly', 'angle', 'none' */
+    bracketStyle: 'square' | 'round' | 'curly' | 'angle' | 'none';
+}
+export declare const DEFAULT_INDICATOR_CONFIG: IndicatorConfig;
+export declare const INDICATOR_STYLES: {
+    full: string;
+    minimal: string;
+    compact: string;
+    custom: string;
+};
+export declare const BRACKETS: {
+    square: {
+        open: string;
+        close: string;
+    };
+    round: {
+        open: string;
+        close: string;
+    };
+    curly: {
+        open: string;
+        close: string;
+    };
+    angle: {
+        open: string;
+        close: string;
+    };
+    none: {
+        open: string;
+        close: string;
+    };
+};
+/**
+ * Load indicator configuration from environment variables or use defaults.
+ * Environment variables take precedence over default values.
+ *
+ * @returns {IndicatorConfig} The loaded configuration
+ * @example
+ * ```typescript
+ * // Set environment variables before loading
+ * process.env.DOLLHOUSE_INDICATOR_STYLE = 'minimal';
+ * process.env.DOLLHOUSE_INDICATOR_EMOJI = '🤖';
+ *
+ * const config = loadIndicatorConfig();
+ * // config.style === 'minimal'
+ * // config.emoji === '🤖'
+ * ```
+ */
+export declare function loadIndicatorConfig(): IndicatorConfig;
+/**
+ * Validate custom format template for valid placeholders
+ */
+export declare function validateCustomFormat(format: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Format the indicator based on configuration and persona metadata
+ */
+export declare function formatIndicator(config: IndicatorConfig, metadata: {
+    name: string;
+    version?: string;
+    author?: string;
+    category?: string;
+}): string;
+//# sourceMappingURL=indicator-config.d.ts.map

package/dist/test/src/config/indicator-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indicator-config.d.ts","sourceRoot":"","sources":["../../../../src/config/indicator-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,eAAe;IAC9B,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IAEjB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAEjD;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,2CAA2C;IAC3C,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IAEtB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAElB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IAEd,iEAAiE;IACjE,YAAY,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;CAC/D;AAGD,eAAO,MAAM,wBAAwB,EAAE,eAWtC,CAAC;AAGF,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAC;AAGF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAMpB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,IAAI,eAAe,CA6CrD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBvF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE;IACR,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,MAAM,CA4DR"}

package/dist/test/src/config/indicator-config.js

@@ -0,0 +1,158 @@
+// Default configuration
+export const DEFAULT_INDICATOR_CONFIG = {
+    enabled: true,
+    style: 'full',
+    showEmoji: true,
+    showName: true,
+    showVersion: true,
+    showAuthor: true,
+    showCategory: false,
+    separator: ' | ',
+    emoji: '🎭',
+    bracketStyle: 'square'
+};
+// Predefined styles
+export const INDICATOR_STYLES = {
+    full: '[{emoji} {name} v{version} by {author}]',
+    minimal: '{emoji} {name}',
+    compact: '[{name} v{version}]',
+    custom: '{customFormat}'
+};
+// Bracket mappings
+export const BRACKETS = {
+    square: { open: '[', close: ']' },
+    round: { open: '(', close: ')' },
+    curly: { open: '{', close: '}' },
+    angle: { open: '<', close: '>' },
+    none: { open: '', close: '' }
+};
+/**
+ * Load indicator configuration from environment variables or use defaults.
+ * Environment variables take precedence over default values.
+ *
+ * @returns {IndicatorConfig} The loaded configuration
+ * @example
+ * ```typescript
+ * // Set environment variables before loading
+ * process.env.DOLLHOUSE_INDICATOR_STYLE = 'minimal';
+ * process.env.DOLLHOUSE_INDICATOR_EMOJI = '🤖';
+ *
+ * const config = loadIndicatorConfig();
+ * // config.style === 'minimal'
+ * // config.emoji === '🤖'
+ * ```
+ */
+export function loadIndicatorConfig() {
+    const config = { ...DEFAULT_INDICATOR_CONFIG };
+    // Check environment variables for overrides
+    if (process.env.DOLLHOUSE_INDICATOR_ENABLED !== undefined) {
+        config.enabled = process.env.DOLLHOUSE_INDICATOR_ENABLED === 'true';
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_STYLE) {
+        const style = process.env.DOLLHOUSE_INDICATOR_STYLE;
+        if (['full', 'minimal', 'compact', 'custom'].includes(style)) {
+            config.style = style;
+        }
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_FORMAT) {
+        config.customFormat = process.env.DOLLHOUSE_INDICATOR_FORMAT;
+        config.style = 'custom';
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_EMOJI) {
+        config.emoji = process.env.DOLLHOUSE_INDICATOR_EMOJI;
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_BRACKETS) {
+        const bracketStyle = process.env.DOLLHOUSE_INDICATOR_BRACKETS;
+        if (['square', 'round', 'curly', 'angle', 'none'].includes(bracketStyle)) {
+            config.bracketStyle = bracketStyle;
+        }
+    }
+    // Parse show flags from environment
+    if (process.env.DOLLHOUSE_INDICATOR_SHOW_VERSION !== undefined) {
+        config.showVersion = process.env.DOLLHOUSE_INDICATOR_SHOW_VERSION === 'true';
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_SHOW_AUTHOR !== undefined) {
+        config.showAuthor = process.env.DOLLHOUSE_INDICATOR_SHOW_AUTHOR === 'true';
+    }
+    if (process.env.DOLLHOUSE_INDICATOR_SHOW_CATEGORY !== undefined) {
+        config.showCategory = process.env.DOLLHOUSE_INDICATOR_SHOW_CATEGORY === 'true';
+    }
+    return config;
+}
+/**
+ * Validate custom format template for valid placeholders
+ */
+export function validateCustomFormat(format) {
+    const validPlaceholders = ['{emoji}', '{name}', '{version}', '{author}', '{category}'];
+    // Length limit added to prevent ReDoS attacks
+    const placeholderRegex = /\{[^}]{0,50}\}/g; // Limited to 50 chars for placeholder names
+    const foundPlaceholders = format.match(placeholderRegex) || [];
+    for (const placeholder of foundPlaceholders) {
+        if (!validPlaceholders.includes(placeholder)) {
+            return {
+                valid: false,
+                error: `Invalid placeholder: ${placeholder}. Valid placeholders are: ${validPlaceholders.join(', ')}`
+            };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Format the indicator based on configuration and persona metadata
+ */
+export function formatIndicator(config, metadata) {
+    if (!config.enabled) {
+        return '';
+    }
+    // Get the format template based on style
+    let template = INDICATOR_STYLES[config.style];
+    if (config.style === 'custom' && config.customFormat) {
+        // Validate custom format
+        const validation = validateCustomFormat(config.customFormat);
+        if (!validation.valid) {
+            // Fall back to full style if custom format is invalid
+            template = INDICATOR_STYLES.full;
+        }
+        else {
+            template = config.customFormat;
+        }
+    }
+    // Replace placeholders with values or empty strings
+    let result = template
+        .replace('{emoji}', config.showEmoji ? config.emoji : '')
+        .replace('{name}', config.showName ? metadata.name : '')
+        .replace('{version}', config.showVersion && metadata.version ? metadata.version : '')
+        .replace('{author}', config.showAuthor && metadata.author ? metadata.author : '')
+        .replace('{category}', config.showCategory && metadata.category ? metadata.category : '');
+    // Clean up the format string
+    // Remove "v" if no version follows it
+    if (!config.showVersion || !metadata.version) {
+        result = result.replace(/\sv(?=\s|]|\)|>|}|$)/, '');
+    }
+    // Remove "by" if no author follows it
+    if (!config.showAuthor || !metadata.author) {
+        result = result.replace(/\sby(?=\s|]|\)|>|}|$)/, '');
+    }
+    // Clean up extra spaces
+    result = result.replace(/\s+/g, ' ').trim();
+    // Apply brackets based on the template format (only if template doesn't already have them)
+    if (result && config.style !== 'custom') {
+        // Check if the template already includes brackets
+        const templateHasBrackets = template.includes('[') || template.includes(']') ||
+            template.includes('(') || template.includes(')') ||
+            template.includes('{') || template.includes('}') ||
+            template.includes('<') || template.includes('>');
+        if (!templateHasBrackets) {
+            const brackets = BRACKETS[config.bracketStyle];
+            if (brackets.open || brackets.close) {
+                result = `${brackets.open}${result}${brackets.close}`;
+            }
+        }
+    }
+    // Add separator if we have content
+    if (result) {
+        result += config.separator;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indicator-config.js","sourceRoot":"","sources":["../../../../src/config/indicator-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration interface for the persona active indicator system.\n * Controls how persona information is displayed in AI responses.\n * \n * @interface IndicatorConfig\n * @example\n * ```typescript\n * const config: IndicatorConfig = {\n *   enabled: true,\n *   style: 'full',\n *   showEmoji: true,\n *   showName: true,\n *   showVersion: true,\n *   showAuthor: true,\n *   showCategory: false,\n *   separator: ' | ',\n *   emoji: '🎭',\n *   bracketStyle: 'square'\n * };\n * ```\n */\nexport interface IndicatorConfig {\n  /** Whether to show the indicator at all */\n  enabled: boolean;\n  \n  /** Format style: 'full', 'minimal', 'compact', 'custom' */\n  style: 'full' | 'minimal' | 'compact' | 'custom';\n  \n  /** \n   * Custom format template (used when style is 'custom')\n   * Available placeholders: {emoji}, {name}, {version}, {author}, {category}\n   */\n  customFormat?: string;\n  \n  /** Whether to include specific elements */\n  showEmoji: boolean;\n  showName: boolean;\n  showVersion: boolean;\n  showAuthor: boolean;\n  showCategory: boolean;\n  \n  /** Separator between indicator and response */\n  separator: string;\n  \n  /** Emoji to use (defaults to 🎭) */\n  emoji: string;\n  \n  /** Bracket style: 'square', 'round', 'curly', 'angle', 'none' */\n  bracketStyle: 'square' | 'round' | 'curly' | 'angle' | 'none';\n}\n\n// Default configuration\nexport const DEFAULT_INDICATOR_CONFIG: IndicatorConfig = {\n  enabled: true,\n  style: 'full',\n  showEmoji: true,\n  showName: true,\n  showVersion: true,\n  showAuthor: true,\n  showCategory: false,\n  separator: ' | ',\n  emoji: '🎭',\n  bracketStyle: 'square'\n};\n\n// Predefined styles\nexport const INDICATOR_STYLES = {\n  full: '[{emoji} {name} v{version} by {author}]',\n  minimal: '{emoji} {name}',\n  compact: '[{name} v{version}]',\n  custom: '{customFormat}'\n};\n\n// Bracket mappings\nexport const BRACKETS = {\n  square: { open: '[', close: ']' },\n  round: { open: '(', close: ')' },\n  curly: { open: '{', close: '}' },\n  angle: { open: '<', close: '>' },\n  none: { open: '', close: '' }\n};\n\n/**\n * Load indicator configuration from environment variables or use defaults.\n * Environment variables take precedence over default values.\n * \n * @returns {IndicatorConfig} The loaded configuration\n * @example\n * ```typescript\n * // Set environment variables before loading\n * process.env.DOLLHOUSE_INDICATOR_STYLE = 'minimal';\n * process.env.DOLLHOUSE_INDICATOR_EMOJI = '🤖';\n * \n * const config = loadIndicatorConfig();\n * // config.style === 'minimal'\n * // config.emoji === '🤖'\n * ```\n */\nexport function loadIndicatorConfig(): IndicatorConfig {\n  const config = { ...DEFAULT_INDICATOR_CONFIG };\n  \n  // Check environment variables for overrides\n  if (process.env.DOLLHOUSE_INDICATOR_ENABLED !== undefined) {\n    config.enabled = process.env.DOLLHOUSE_INDICATOR_ENABLED === 'true';\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_STYLE) {\n    const style = process.env.DOLLHOUSE_INDICATOR_STYLE;\n    if (['full', 'minimal', 'compact', 'custom'].includes(style)) {\n      config.style = style as IndicatorConfig['style'];\n    }\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_FORMAT) {\n    config.customFormat = process.env.DOLLHOUSE_INDICATOR_FORMAT;\n    config.style = 'custom';\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_EMOJI) {\n    config.emoji = process.env.DOLLHOUSE_INDICATOR_EMOJI;\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_BRACKETS) {\n    const bracketStyle = process.env.DOLLHOUSE_INDICATOR_BRACKETS;\n    if (['square', 'round', 'curly', 'angle', 'none'].includes(bracketStyle)) {\n      config.bracketStyle = bracketStyle as IndicatorConfig['bracketStyle'];\n    }\n  }\n  \n  // Parse show flags from environment\n  if (process.env.DOLLHOUSE_INDICATOR_SHOW_VERSION !== undefined) {\n    config.showVersion = process.env.DOLLHOUSE_INDICATOR_SHOW_VERSION === 'true';\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_SHOW_AUTHOR !== undefined) {\n    config.showAuthor = process.env.DOLLHOUSE_INDICATOR_SHOW_AUTHOR === 'true';\n  }\n  \n  if (process.env.DOLLHOUSE_INDICATOR_SHOW_CATEGORY !== undefined) {\n    config.showCategory = process.env.DOLLHOUSE_INDICATOR_SHOW_CATEGORY === 'true';\n  }\n  \n  return config;\n}\n\n/**\n * Validate custom format template for valid placeholders\n */\nexport function validateCustomFormat(format: string): { valid: boolean; error?: string } {\n  const validPlaceholders = ['{emoji}', '{name}', '{version}', '{author}', '{category}'];\n  // Length limit added to prevent ReDoS attacks\n  const placeholderRegex = /\\{[^}]{0,50}\\}/g;  // Limited to 50 chars for placeholder names\n  const foundPlaceholders = format.match(placeholderRegex) || [];\n  \n  for (const placeholder of foundPlaceholders) {\n    if (!validPlaceholders.includes(placeholder)) {\n      return {\n        valid: false,\n        error: `Invalid placeholder: ${placeholder}. Valid placeholders are: ${validPlaceholders.join(', ')}`\n      };\n    }\n  }\n  \n  return { valid: true };\n}\n\n/**\n * Format the indicator based on configuration and persona metadata\n */\nexport function formatIndicator(\n  config: IndicatorConfig,\n  metadata: {\n    name: string;\n    version?: string;\n    author?: string;\n    category?: string;\n  }\n): string {\n  if (!config.enabled) {\n    return '';\n  }\n  \n  // Get the format template based on style\n  let template = INDICATOR_STYLES[config.style];\n  if (config.style === 'custom' && config.customFormat) {\n    // Validate custom format\n    const validation = validateCustomFormat(config.customFormat);\n    if (!validation.valid) {\n      // Fall back to full style if custom format is invalid\n      template = INDICATOR_STYLES.full;\n    } else {\n      template = config.customFormat;\n    }\n  }\n  \n  // Replace placeholders with values or empty strings\n  let result = template\n    .replace('{emoji}', config.showEmoji ? config.emoji : '')\n    .replace('{name}', config.showName ? metadata.name : '')\n    .replace('{version}', config.showVersion && metadata.version ? metadata.version : '')\n    .replace('{author}', config.showAuthor && metadata.author ? metadata.author : '')\n    .replace('{category}', config.showCategory && metadata.category ? metadata.category : '');\n  \n  // Clean up the format string\n  // Remove \"v\" if no version follows it\n  if (!config.showVersion || !metadata.version) {\n    result = result.replace(/\\sv(?=\\s|]|\\)|>|}|$)/, '');\n  }\n  // Remove \"by\" if no author follows it\n  if (!config.showAuthor || !metadata.author) {\n    result = result.replace(/\\sby(?=\\s|]|\\)|>|}|$)/, '');\n  }\n  // Clean up extra spaces\n  result = result.replace(/\\s+/g, ' ').trim();\n  \n  // Apply brackets based on the template format (only if template doesn't already have them)\n  if (result && config.style !== 'custom') {\n    // Check if the template already includes brackets\n    const templateHasBrackets = template.includes('[') || template.includes(']') || \n                               template.includes('(') || template.includes(')') ||\n                               template.includes('{') || template.includes('}') ||\n                               template.includes('<') || template.includes('>');\n    \n    if (!templateHasBrackets) {\n      const brackets = BRACKETS[config.bracketStyle];\n      if (brackets.open || brackets.close) {\n        result = `${brackets.open}${result}${brackets.close}`;\n      }\n    }\n  }\n  \n  // Add separator if we have content\n  if (result) {\n    result += config.separator;\n  }\n  \n  return result;\n}"]}

package/dist/test/src/constants/defaultPersonas.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default personas that ship with DollhouseMCP
+ */
+export declare const DEFAULT_PERSONAS: readonly ["business-consultant.md", "creative-writer.md", "debug-detective.md", "eli5-explainer.md", "excel-expert.md", "technical-analyst.md"];
+export type DefaultPersonaFilename = typeof DEFAULT_PERSONAS[number];
+/**
+ * Check if a filename is a default persona
+ */
+export declare function isDefaultPersona(filename: string): boolean;
+//# sourceMappingURL=defaultPersonas.d.ts.map