@dollhousemcp/mcp-server 1.7.3 → 1.8.0

package/dist/config/ConfigWizardCheck.js

@@ -0,0 +1,208 @@
+/**
+ * ConfigWizardCheck - Handles checking if the configuration wizard should run
+ * on first interaction with the MCP server
+ */
+import { ConfigManager } from './ConfigManager.js';
+import { logger } from '../utils/logger.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+export class ConfigWizardCheck {
+    hasCheckedWizard = false;
+    configManager;
+    currentVersion;
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.currentVersion = this.getCurrentVersion();
+    }
+    /**
+     * Get the current version from package.json
+     */
+    getCurrentVersion() {
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const packagePath = join(__dirname, '..', '..', 'package.json');
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            return packageJson.version;
+        }
+        catch (error) {
+            logger.warn('Could not read package.json version', { error });
+            return '0.0.0';
+        }
+    }
+    /**
+     * Check if configuration wizard should run on first interaction
+     * Returns a prompt message if wizard should run, null otherwise
+     */
+    async checkIfWizardNeeded() {
+        // Only check once per session
+        if (this.hasCheckedWizard) {
+            return null;
+        }
+        this.hasCheckedWizard = true;
+        try {
+            // Initialize config if not already done
+            await this.configManager.initialize();
+            const config = this.configManager.getConfig();
+            // Check if this is a first-time user
+            if (!config.wizard?.completed && !config.wizard?.dismissed) {
+                // First time user - show welcome wizard
+                return this.getWizardPrompt();
+            }
+            // Check if we should show update wizard for existing users
+            if (config.wizard?.completed && this.shouldShowUpdateWizard(config.wizard?.lastSeenVersion)) {
+                // Update the last seen version
+                await this.configManager.updateSetting('wizard.lastSeenVersion', this.currentVersion);
+                return this.getUpdateWizardPrompt();
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error('Error checking config wizard status', { error });
+            return null;
+        }
+    }
+    /**
+     * Determine if we should show the update wizard based on version changes
+     * This logic can be updated with each release to trigger when needed
+     */
+    shouldShowUpdateWizard(lastSeenVersion) {
+        // If no last seen version, they've never seen an update wizard
+        if (!lastSeenVersion) {
+            return false; // Don't show update to very old users who haven't seen versioning yet
+        }
+        // DEPLOYMENT NOTE: Update this logic when you want to trigger the wizard
+        // Examples:
+        // - For emergency notifications: return true;
+        // - For major features: return this.currentVersion >= '1.8.0' && lastSeenVersion < '1.8.0';
+        // - For breaking changes: return this.currentVersion.startsWith('2.') && lastSeenVersion.startsWith('1.');
+        // Currently: Don't trigger update wizard (can be changed in any release)
+        return false;
+    }
+    /**
+     * Get the wizard prompt message - friendly for non-technical users
+     */
+    getWizardPrompt() {
+        return `🎨 **Welcome to DollhouseMCP!**
+
+Hi there! I see this is your first time here. DollhouseMCP helps you create powerful customization elements for your AI assistant - and it's easier than you might think!
+
+**What can you do with DollhouseMCP?**
+
+🎭 **Personas** - Change your AI's personality (make it funny, professional, creative, or anything you imagine)
+💡 **Skills** - Give your AI new abilities like taking meeting notes, reviewing code, or organizing your thoughts
+📝 **Templates** - Create reusable formats for emails, documentation, resumes, and more
+🤖 **Agents** - Build smart assistants that handle specific tasks automatically
+✨ **And more!** - Just describe what you want, and DollhouseMCP will help you create it
+
+The best part? Everything you create is saved and persistent. Your custom tools and assistants will be there whenever you need them. You can modify them anytime just by asking!
+
+**Need ideas?** Just ask "What would be the best way to..." and I'll help you figure out the perfect solution.
+
+**Ready to get started?** I'll help you:
+- Choose a username (this tags your creations so you can find them later - or stay anonymous, that's totally fine!)
+- Set up your workspace for saving all your customizations
+- Browse examples to spark your creativity
+- Create your first customization element
+
+Just say:
+- "Yes" or "Let's get started" → I'll guide you through setup
+- "Skip for now" → You can set up later when you're ready
+- "I'll stay anonymous" → Perfect! You can use everything without signing in
+
+**What's a username for?** It simply tags your creations (like "created by: you") so you can find them easily. Staying anonymous means your creations are tagged with a fun random ID instead (like "created by: clever-fox"). Either way, all your work is saved locally on your computer!
+
+Don't worry - this only takes a minute, and you can change any settings later! 🌟`;
+    }
+    /**
+     * Get the update wizard prompt for returning users
+     * This can be customized for each release that needs to notify users
+     */
+    getUpdateWizardPrompt() {
+        // This template can be customized for each release
+        return `🎉 **DollhouseMCP Has New Features!**
+
+Welcome back! We've added some exciting new capabilities since you last used DollhouseMCP.
+
+**What's New:**
+- Enhanced configuration options
+- Improved user experience
+- Better performance
+
+Would you like me to show you what's new, or would you prefer to explore on your own?
+
+Just say:
+- "Show me what's new" → I'll guide you through the updates
+- "Skip for now" → Continue with your work
+
+You can always ask "What's new in DollhouseMCP?" later to see this again.`;
+    }
+    /**
+     * Wrap tool responses to check for wizard on first interaction
+     * CRITICAL FIX: Create new response objects to avoid mutations
+     */
+    async wrapResponse(response) {
+        const wizardPrompt = await this.checkIfWizardNeeded();
+        if (!wizardPrompt) {
+            return response;
+        }
+        // Always create new response objects to avoid mutation
+        const wizardContent = {
+            type: "text",
+            text: wizardPrompt
+        };
+        const separator = {
+            type: "text",
+            text: "\n\n---\n\n"
+        };
+        // Handle different response formats
+        if (response?.content && Array.isArray(response.content)) {
+            // Create new response with spread to avoid mutation
+            return {
+                ...response,
+                content: [wizardContent, separator, ...response.content]
+            };
+        }
+        else if (typeof response === 'object' && response !== null) {
+            // Handle non-standard response formats gracefully
+            const originalText = response?.content?.[0]?.text ||
+                response?.text ||
+                response?.message ||
+                "Tool executed successfully";
+            return {
+                content: [
+                    wizardContent,
+                    separator,
+                    { type: "text", text: originalText }
+                ]
+            };
+        }
+        else {
+            // Fallback for primitive responses (including null/undefined)
+            const text = response == null ? "Tool executed successfully" : String(response);
+            return {
+                content: [
+                    wizardContent,
+                    separator,
+                    { type: "text", text }
+                ]
+            };
+        }
+    }
+    /**
+     * Mark wizard as completed
+     */
+    async markWizardCompleted() {
+        await this.configManager.updateSetting('wizard.completed', true);
+        await this.configManager.updateSetting('wizard.completedAt', new Date().toISOString());
+        await this.configManager.updateSetting('wizard.lastSeenVersion', this.currentVersion);
+    }
+    /**
+     * Mark wizard as dismissed
+     */
+    async markWizardDismissed() {
+        await this.configManager.updateSetting('wizard.dismissed', true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigWizardCheck.js","sourceRoot":"","sources":["../../src/config/ConfigWizardCheck.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ConfigWizardCheck - Handles checking if the configuration wizard should run\n * on first interaction with the MCP server\n */\n\nimport { ConfigManager } from './ConfigManager.js';\nimport { logger } from '../utils/logger.js';\nimport { readFileSync } from 'fs';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\nexport class ConfigWizardCheck {\n  private hasCheckedWizard: boolean = false;\n  private configManager: ConfigManager;\n  private currentVersion: string;\n\n  constructor() {\n    this.configManager = ConfigManager.getInstance();\n    this.currentVersion = this.getCurrentVersion();\n  }\n  \n  /**\n   * Get the current version from package.json\n   */\n  private getCurrentVersion(): string {\n    try {\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = dirname(__filename);\n      const packagePath = join(__dirname, '..', '..', 'package.json');\n      const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));\n      return packageJson.version;\n    } catch (error) {\n      logger.warn('Could not read package.json version', { error });\n      return '0.0.0';\n    }\n  }\n\n  /**\n   * Check if configuration wizard should run on first interaction\n   * Returns a prompt message if wizard should run, null otherwise\n   */\n  async checkIfWizardNeeded(): Promise<string | null> {\n    // Only check once per session\n    if (this.hasCheckedWizard) {\n      return null;\n    }\n    \n    this.hasCheckedWizard = true;\n    \n    try {\n      // Initialize config if not already done\n      await this.configManager.initialize();\n      const config = this.configManager.getConfig();\n      \n      // Check if this is a first-time user\n      if (!config.wizard?.completed && !config.wizard?.dismissed) {\n        // First time user - show welcome wizard\n        return this.getWizardPrompt();\n      }\n      \n      // Check if we should show update wizard for existing users\n      if (config.wizard?.completed && this.shouldShowUpdateWizard(config.wizard?.lastSeenVersion)) {\n        // Update the last seen version\n        await this.configManager.updateSetting('wizard.lastSeenVersion', this.currentVersion);\n        return this.getUpdateWizardPrompt();\n      }\n      \n      return null;\n      \n    } catch (error) {\n      logger.error('Error checking config wizard status', { error });\n      return null;\n    }\n  }\n  \n  /**\n   * Determine if we should show the update wizard based on version changes\n   * This logic can be updated with each release to trigger when needed\n   */\n  private shouldShowUpdateWizard(lastSeenVersion?: string): boolean {\n    // If no last seen version, they've never seen an update wizard\n    if (!lastSeenVersion) {\n      return false; // Don't show update to very old users who haven't seen versioning yet\n    }\n    \n    // DEPLOYMENT NOTE: Update this logic when you want to trigger the wizard\n    // Examples:\n    // - For emergency notifications: return true;\n    // - For major features: return this.currentVersion >= '1.8.0' && lastSeenVersion < '1.8.0';\n    // - For breaking changes: return this.currentVersion.startsWith('2.') && lastSeenVersion.startsWith('1.');\n    \n    // Currently: Don't trigger update wizard (can be changed in any release)\n    return false;\n  }\n\n  /**\n   * Get the wizard prompt message - friendly for non-technical users\n   */\n  private getWizardPrompt(): string {\n    return `🎨 **Welcome to DollhouseMCP!**\n\nHi there! I see this is your first time here. DollhouseMCP helps you create powerful customization elements for your AI assistant - and it's easier than you might think!\n\n**What can you do with DollhouseMCP?**\n\n🎭 **Personas** - Change your AI's personality (make it funny, professional, creative, or anything you imagine)\n💡 **Skills** - Give your AI new abilities like taking meeting notes, reviewing code, or organizing your thoughts\n📝 **Templates** - Create reusable formats for emails, documentation, resumes, and more\n🤖 **Agents** - Build smart assistants that handle specific tasks automatically\n✨ **And more!** - Just describe what you want, and DollhouseMCP will help you create it\n\nThe best part? Everything you create is saved and persistent. Your custom tools and assistants will be there whenever you need them. You can modify them anytime just by asking!\n\n**Need ideas?** Just ask \"What would be the best way to...\" and I'll help you figure out the perfect solution.\n\n**Ready to get started?** I'll help you:\n- Choose a username (this tags your creations so you can find them later - or stay anonymous, that's totally fine!)\n- Set up your workspace for saving all your customizations\n- Browse examples to spark your creativity\n- Create your first customization element\n\nJust say:\n- \"Yes\" or \"Let's get started\" → I'll guide you through setup\n- \"Skip for now\" → You can set up later when you're ready\n- \"I'll stay anonymous\" → Perfect! You can use everything without signing in\n\n**What's a username for?** It simply tags your creations (like \"created by: you\") so you can find them easily. Staying anonymous means your creations are tagged with a fun random ID instead (like \"created by: clever-fox\"). Either way, all your work is saved locally on your computer!\n\nDon't worry - this only takes a minute, and you can change any settings later! 🌟`;\n  }\n  \n  /**\n   * Get the update wizard prompt for returning users\n   * This can be customized for each release that needs to notify users\n   */\n  private getUpdateWizardPrompt(): string {\n    // This template can be customized for each release\n    return `🎉 **DollhouseMCP Has New Features!**\n\nWelcome back! We've added some exciting new capabilities since you last used DollhouseMCP.\n\n**What's New:**\n- Enhanced configuration options\n- Improved user experience\n- Better performance\n\nWould you like me to show you what's new, or would you prefer to explore on your own?\n\nJust say:\n- \"Show me what's new\" → I'll guide you through the updates\n- \"Skip for now\" → Continue with your work\n\nYou can always ask \"What's new in DollhouseMCP?\" later to see this again.`;\n  }\n\n  /**\n   * Wrap tool responses to check for wizard on first interaction\n   * CRITICAL FIX: Create new response objects to avoid mutations\n   */\n  async wrapResponse(response: any): Promise<any> {\n    const wizardPrompt = await this.checkIfWizardNeeded();\n    \n    if (!wizardPrompt) {\n      return response;\n    }\n\n    // Always create new response objects to avoid mutation\n    const wizardContent = {\n      type: \"text\",\n      text: wizardPrompt\n    };\n\n    const separator = {\n      type: \"text\",\n      text: \"\\n\\n---\\n\\n\"\n    };\n\n    // Handle different response formats\n    if (response?.content && Array.isArray(response.content)) {\n      // Create new response with spread to avoid mutation\n      return {\n        ...response,\n        content: [wizardContent, separator, ...response.content]\n      };\n    } else if (typeof response === 'object' && response !== null) {\n      // Handle non-standard response formats gracefully\n      const originalText = response?.content?.[0]?.text || \n                          response?.text || \n                          response?.message || \n                          \"Tool executed successfully\";\n      \n      return {\n        content: [\n          wizardContent,\n          separator,\n          { type: \"text\", text: originalText }\n        ]\n      };\n    } else {\n      // Fallback for primitive responses (including null/undefined)\n      const text = response == null ? \"Tool executed successfully\" : String(response);\n      return {\n        content: [\n          wizardContent,\n          separator,\n          { type: \"text\", text }\n        ]\n      };\n    }\n  }\n\n  /**\n   * Mark wizard as completed\n   */\n  async markWizardCompleted(): Promise<void> {\n    await this.configManager.updateSetting('wizard.completed', true);\n    await this.configManager.updateSetting('wizard.completedAt', new Date().toISOString());\n    await this.configManager.updateSetting('wizard.lastSeenVersion', this.currentVersion);\n  }\n\n  /**\n   * Mark wizard as dismissed\n   */\n  async markWizardDismissed(): Promise<void> {\n    await this.configManager.updateSetting('wizard.dismissed', true);\n  }\n}"]}

package/dist/config/portfolioConfig.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Portfolio configuration utilities
+ * Handles repository name configuration for portfolio sync
+ */
+/**
+ * Get the configured portfolio repository name
+ * Priority order:
+ * 1. TEST_GITHUB_REPO environment variable (for testing)
+ * 2. Configured repository name (future: from config file)
+ * 3. Default: 'dollhouse-portfolio'
+ *
+ * @example
+ * // Default usage
+ * const repo = getPortfolioRepositoryName(); // 'dollhouse-portfolio'
+ *
+ * @example
+ * // With TEST_GITHUB_REPO set
+ * process.env.TEST_GITHUB_REPO = 'test-portfolio';
+ * const repo = getPortfolioRepositoryName(); // 'test-portfolio'
+ *
+ * @returns {string} The configured portfolio repository name
+ */
+export declare function getPortfolioRepositoryName(): string;
+/**
+ * Check if we're in a test environment
+ *
+ * @example
+ * // When TEST_GITHUB_REPO is set
+ * process.env.TEST_GITHUB_REPO = 'test-repo';
+ * const isTest = isTestEnvironment(); // true
+ *
+ * @example
+ * // In production environment
+ * delete process.env.TEST_GITHUB_REPO;
+ * const isTest = isTestEnvironment(); // false
+ *
+ * @returns {boolean} True if running in a test environment
+ */
+export declare function isTestEnvironment(): boolean;
+//# sourceMappingURL=portfolioConfig.d.ts.map

package/dist/config/portfolioConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portfolioConfig.d.ts","sourceRoot":"","sources":["../../src/config/portfolioConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAgBnD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAI3C"}

package/dist/config/portfolioConfig.js

@@ -0,0 +1,58 @@
+/**
+ * Portfolio configuration utilities
+ * Handles repository name configuration for portfolio sync
+ */
+/**
+ * Get the configured portfolio repository name
+ * Priority order:
+ * 1. TEST_GITHUB_REPO environment variable (for testing)
+ * 2. Configured repository name (future: from config file)
+ * 3. Default: 'dollhouse-portfolio'
+ *
+ * @example
+ * // Default usage
+ * const repo = getPortfolioRepositoryName(); // 'dollhouse-portfolio'
+ *
+ * @example
+ * // With TEST_GITHUB_REPO set
+ * process.env.TEST_GITHUB_REPO = 'test-portfolio';
+ * const repo = getPortfolioRepositoryName(); // 'test-portfolio'
+ *
+ * @returns {string} The configured portfolio repository name
+ */
+export function getPortfolioRepositoryName() {
+    // For testing environments, use TEST_GITHUB_REPO if set
+    // Trim whitespace to handle edge cases
+    const testRepo = process.env.TEST_GITHUB_REPO?.trim();
+    if (testRepo) {
+        return testRepo;
+    }
+    // TODO: Add support for reading from config file
+    // const config = ConfigManager.getInstance();
+    // if (config.github?.portfolio?.repository_name) {
+    //   return config.github.portfolio.repository_name;
+    // }
+    // Default repository name
+    return 'dollhouse-portfolio';
+}
+/**
+ * Check if we're in a test environment
+ *
+ * @example
+ * // When TEST_GITHUB_REPO is set
+ * process.env.TEST_GITHUB_REPO = 'test-repo';
+ * const isTest = isTestEnvironment(); // true
+ *
+ * @example
+ * // In production environment
+ * delete process.env.TEST_GITHUB_REPO;
+ * const isTest = isTestEnvironment(); // false
+ *
+ * @returns {boolean} True if running in a test environment
+ */
+export function isTestEnvironment() {
+    return process.env.TEST_MODE === 'true' ||
+        process.env.NODE_ENV === 'test' ||
+        !!process.env.TEST_GITHUB_REPO?.trim();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config/wizardTemplates.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Wizard Text Templates
+ *
+ * Centralized configuration for all wizard text to support:
+ * - Internationalization (i18n) in the future
+ * - Consistent messaging across the application
+ * - Easy updates without modifying business logic
+ * - Template reusability
+ */
+export interface WizardTemplates {
+    title: string;
+    currentConfigHeader: string;
+    steps: {
+        userIdentity: WizardStep;
+        githubIntegration: WizardStep;
+        portfolioSync: WizardStep;
+        displayPreferences: WizardStep;
+    };
+    instructions: {
+        quick: string;
+        detailed: string;
+        skip: string;
+    };
+    footer: string;
+}
+export interface WizardStep {
+    title: string;
+    description: string;
+    instructions: string[];
+    currentValue: (value: any) => string;
+}
+/**
+ * Default English templates
+ */
+export declare const defaultWizardTemplates: WizardTemplates;
+/**
+ * Friendly value replacements for null/undefined config values
+ */
+export declare const friendlyNullValues: Record<string, string>;
+/**
+ * Helper function to get wizard text in specified language
+ * @param language - Language code (e.g., 'en', 'es', 'fr')
+ * @returns Wizard templates for the specified language
+ */
+export declare function getWizardTemplates(language?: string): WizardTemplates;
+/**
+ * Helper function to get friendly null value
+ * @param path - Dot-notation path to the config field
+ * @returns Friendly message for null value
+ */
+export declare function getFriendlyNullValue(path: string): string;
+/**
+ * Template builder for wizard steps
+ * Allows for dynamic construction of wizard content
+ */
+export declare class WizardTemplateBuilder {
+    private templates;
+    constructor(language?: string);
+    /**
+     * Build the complete wizard text
+     */
+    buildWizardText(currentConfig: any): string;
+    /**
+     * Build current configuration section
+     */
+    private buildCurrentConfig;
+    /**
+     * Build all wizard steps
+     */
+    private buildSteps;
+    /**
+     * Format a single wizard step
+     */
+    private formatStep;
+    /**
+     * Build instruction options
+     */
+    private buildInstructions;
+    /**
+     * Format config as YAML (stub - would use actual yaml library)
+     */
+    private formatConfigAsYaml;
+}
+//# sourceMappingURL=wizardTemplates.d.ts.map

package/dist/config/wizardTemplates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wizardTemplates.d.ts","sourceRoot":"","sources":["../../src/config/wizardTemplates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE;QACL,YAAY,EAAE,UAAU,CAAC;QACzB,iBAAiB,EAAE,UAAU,CAAC;QAC9B,aAAa,EAAE,UAAU,CAAC;QAC1B,kBAAkB,EAAE,UAAU,CAAC;KAChC,CAAC;IACF,YAAY,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC;CACtC;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAqDpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA0BrD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,GAAE,MAAa,GAAG,eAAe,CAQ3E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,SAAS,CAAkB;gBAEvB,QAAQ,GAAE,MAAa;IAInC;;OAEG;IACH,eAAe,CAAC,aAAa,EAAE,GAAG,GAAG,MAAM;IAgB3C;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAsBlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAelB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAK3B"}

package/dist/config/wizardTemplates.js

@@ -0,0 +1,195 @@
+/**
+ * Wizard Text Templates
+ *
+ * Centralized configuration for all wizard text to support:
+ * - Internationalization (i18n) in the future
+ * - Consistent messaging across the application
+ * - Easy updates without modifying business logic
+ * - Template reusability
+ */
+/**
+ * Default English templates
+ */
+export const defaultWizardTemplates = {
+    title: '🧙 Configuration Wizard',
+    currentConfigHeader: '📊 Current Configuration:',
+    steps: {
+        userIdentity: {
+            title: '🎯 Step 1: User Identity',
+            description: 'This tags your creations so you can find them later. Everything is saved locally on your computer.',
+            instructions: [
+                'To set a username: Say "Set my username to [your-name]"',
+                'To stay anonymous: Say "I\'ll stay anonymous"',
+            ],
+            currentValue: (value) => value || '(not set - anonymous mode)',
+        },
+        githubIntegration: {
+            title: '🔐 Step 2: GitHub Integration (Optional)',
+            description: 'Connect to GitHub to share your creations and browse community content.',
+            instructions: [
+                'To connect GitHub: Say "Connect my GitHub account"',
+                'To skip: Say "Skip GitHub for now"',
+            ],
+            currentValue: (value) => value ? 'Connected' : '(not connected)',
+        },
+        portfolioSync: {
+            title: '🔄 Step 3: Portfolio Sync (Optional)',
+            description: 'Automatically backup your creations to GitHub.',
+            instructions: [
+                'To enable: Say "Enable auto-sync"',
+                'To keep manual: Say "I\'ll sync manually"',
+            ],
+            currentValue: (value) => value ? 'Enabled' : 'Manual',
+        },
+        displayPreferences: {
+            title: '🎨 Step 4: Display Preferences',
+            description: 'Customize how DollhouseMCP shows information.',
+            instructions: [
+                'To show active persona: Say "Show persona indicators"',
+                'To keep minimal: Say "Use minimal display"',
+            ],
+            currentValue: (value) => value ? 'Enabled' : 'Minimal',
+        },
+    },
+    instructions: {
+        quick: '💡 **Quick Setup**: Say "Configure the basics" to set just username and GitHub',
+        detailed: '📝 **Detailed Setup**: Say "Configure everything" to go through all options',
+        skip: '⏭️ **Skip for Now**: Say "Skip wizard" to use anonymous mode',
+    },
+    footer: '✨ You can always change these settings later by saying "Open configuration wizard"',
+};
+/**
+ * Friendly value replacements for null/undefined config values
+ */
+export const friendlyNullValues = {
+    // User fields
+    'user.username': '(not set - anonymous mode active)',
+    'user.email': '(optional - not set)',
+    'user.display_name': '(not set - will use username)',
+    // GitHub fields
+    'github.auth_token': '(not configured - GitHub features disabled)',
+    'github.oauth_token': '(not authenticated)',
+    'github.default_repository': '(not set - will use default)',
+    'github.username': '(not connected)',
+    // Portfolio sync fields
+    'portfolio.sync_status.last_sync': '(never synced)',
+    'portfolio.sync_status.last_push': '(never pushed)',
+    'portfolio.sync_status.last_pull': '(never pulled)',
+    'portfolio.repository_name': `(using default: ${process.env.TEST_GITHUB_REPO || 'dollhouse-portfolio'})`,
+    // Collection submission
+    'collection_submission.auto_submit': '(disabled)',
+    // Indicator settings
+    'indicator.custom_format': '(using default format)',
+    // Default for any other null
+    'default': '(not set)',
+};
+/**
+ * Helper function to get wizard text in specified language
+ * @param language - Language code (e.g., 'en', 'es', 'fr')
+ * @returns Wizard templates for the specified language
+ */
+export function getWizardTemplates(language = 'en') {
+    // For now, only English is supported
+    // Future: Load from language-specific files
+    switch (language) {
+        case 'en':
+        default:
+            return defaultWizardTemplates;
+    }
+}
+/**
+ * Helper function to get friendly null value
+ * @param path - Dot-notation path to the config field
+ * @returns Friendly message for null value
+ */
+export function getFriendlyNullValue(path) {
+    return friendlyNullValues[path] || friendlyNullValues['default'];
+}
+/**
+ * Template builder for wizard steps
+ * Allows for dynamic construction of wizard content
+ */
+export class WizardTemplateBuilder {
+    templates;
+    constructor(language = 'en') {
+        this.templates = getWizardTemplates(language);
+    }
+    /**
+     * Build the complete wizard text
+     */
+    buildWizardText(currentConfig) {
+        const parts = [
+            this.templates.title,
+            '',
+            this.buildCurrentConfig(currentConfig),
+            '',
+            this.buildSteps(currentConfig),
+            '',
+            this.buildInstructions(),
+            '',
+            this.templates.footer,
+        ];
+        return parts.join('\n');
+    }
+    /**
+     * Build current configuration section
+     */
+    buildCurrentConfig(config) {
+        return `${this.templates.currentConfigHeader}
+\`\`\`yaml
+${this.formatConfigAsYaml(config)}
+\`\`\``;
+    }
+    /**
+     * Build all wizard steps
+     */
+    buildSteps(config) {
+        const steps = [];
+        // User Identity
+        const userStep = this.templates.steps.userIdentity;
+        steps.push(this.formatStep(userStep, config.user?.username));
+        // GitHub Integration
+        const githubStep = this.templates.steps.githubIntegration;
+        steps.push(this.formatStep(githubStep, config.github?.auth_token));
+        // Portfolio Sync
+        const portfolioStep = this.templates.steps.portfolioSync;
+        steps.push(this.formatStep(portfolioStep, config.portfolio?.auto_sync));
+        // Display Preferences
+        const displayStep = this.templates.steps.displayPreferences;
+        steps.push(this.formatStep(displayStep, config.indicator?.enabled));
+        return steps.join('\n\n');
+    }
+    /**
+     * Format a single wizard step
+     */
+    formatStep(step, currentValue) {
+        const lines = [
+            step.title,
+            step.description,
+        ];
+        for (const instruction of step.instructions) {
+            lines.push(`- ${instruction}`);
+        }
+        lines.push(`- Current: ${step.currentValue(currentValue)}`);
+        return lines.join('\n');
+    }
+    /**
+     * Build instruction options
+     */
+    buildInstructions() {
+        return [
+            this.templates.instructions.quick,
+            this.templates.instructions.detailed,
+            this.templates.instructions.skip,
+        ].join('\n');
+    }
+    /**
+     * Format config as YAML (stub - would use actual yaml library)
+     */
+    formatConfigAsYaml(config) {
+        // This would use the actual yaml.dump with friendly values
+        // For now, return a placeholder
+        return 'user:\n  username: (not set)\n  email: (optional)';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizardTemplates.js","sourceRoot":"","sources":["../../src/config/wizardTemplates.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Wizard Text Templates\n * \n * Centralized configuration for all wizard text to support:\n * - Internationalization (i18n) in the future\n * - Consistent messaging across the application\n * - Easy updates without modifying business logic\n * - Template reusability\n */\n\nexport interface WizardTemplates {\n  title: string;\n  currentConfigHeader: string;\n  steps: {\n    userIdentity: WizardStep;\n    githubIntegration: WizardStep;\n    portfolioSync: WizardStep;\n    displayPreferences: WizardStep;\n  };\n  instructions: {\n    quick: string;\n    detailed: string;\n    skip: string;\n  };\n  footer: string;\n}\n\nexport interface WizardStep {\n  title: string;\n  description: string;\n  instructions: string[];\n  currentValue: (value: any) => string;\n}\n\n/**\n * Default English templates\n */\nexport const defaultWizardTemplates: WizardTemplates = {\n  title: '🧙 Configuration Wizard',\n  currentConfigHeader: '📊 Current Configuration:',\n  \n  steps: {\n    userIdentity: {\n      title: '🎯 Step 1: User Identity',\n      description: 'This tags your creations so you can find them later. Everything is saved locally on your computer.',\n      instructions: [\n        'To set a username: Say \"Set my username to [your-name]\"',\n        'To stay anonymous: Say \"I\\'ll stay anonymous\"',\n      ],\n      currentValue: (value) => value || '(not set - anonymous mode)',\n    },\n    \n    githubIntegration: {\n      title: '🔐 Step 2: GitHub Integration (Optional)',\n      description: 'Connect to GitHub to share your creations and browse community content.',\n      instructions: [\n        'To connect GitHub: Say \"Connect my GitHub account\"',\n        'To skip: Say \"Skip GitHub for now\"',\n      ],\n      currentValue: (value) => value ? 'Connected' : '(not connected)',\n    },\n    \n    portfolioSync: {\n      title: '🔄 Step 3: Portfolio Sync (Optional)',\n      description: 'Automatically backup your creations to GitHub.',\n      instructions: [\n        'To enable: Say \"Enable auto-sync\"',\n        'To keep manual: Say \"I\\'ll sync manually\"',\n      ],\n      currentValue: (value) => value ? 'Enabled' : 'Manual',\n    },\n    \n    displayPreferences: {\n      title: '🎨 Step 4: Display Preferences',\n      description: 'Customize how DollhouseMCP shows information.',\n      instructions: [\n        'To show active persona: Say \"Show persona indicators\"',\n        'To keep minimal: Say \"Use minimal display\"',\n      ],\n      currentValue: (value) => value ? 'Enabled' : 'Minimal',\n    },\n  },\n  \n  instructions: {\n    quick: '💡 **Quick Setup**: Say \"Configure the basics\" to set just username and GitHub',\n    detailed: '📝 **Detailed Setup**: Say \"Configure everything\" to go through all options',\n    skip: '⏭️ **Skip for Now**: Say \"Skip wizard\" to use anonymous mode',\n  },\n  \n  footer: '✨ You can always change these settings later by saying \"Open configuration wizard\"',\n};\n\n/**\n * Friendly value replacements for null/undefined config values\n */\nexport const friendlyNullValues: Record<string, string> = {\n  // User fields\n  'user.username': '(not set - anonymous mode active)',\n  'user.email': '(optional - not set)',\n  'user.display_name': '(not set - will use username)',\n  \n  // GitHub fields\n  'github.auth_token': '(not configured - GitHub features disabled)',\n  'github.oauth_token': '(not authenticated)',\n  'github.default_repository': '(not set - will use default)',\n  'github.username': '(not connected)',\n  \n  // Portfolio sync fields\n  'portfolio.sync_status.last_sync': '(never synced)',\n  'portfolio.sync_status.last_push': '(never pushed)',\n  'portfolio.sync_status.last_pull': '(never pulled)',\n  'portfolio.repository_name': `(using default: ${process.env.TEST_GITHUB_REPO || 'dollhouse-portfolio'})`,\n  \n  // Collection submission\n  'collection_submission.auto_submit': '(disabled)',\n  \n  // Indicator settings\n  'indicator.custom_format': '(using default format)',\n  \n  // Default for any other null\n  'default': '(not set)',\n};\n\n/**\n * Helper function to get wizard text in specified language\n * @param language - Language code (e.g., 'en', 'es', 'fr')\n * @returns Wizard templates for the specified language\n */\nexport function getWizardTemplates(language: string = 'en'): WizardTemplates {\n  // For now, only English is supported\n  // Future: Load from language-specific files\n  switch (language) {\n    case 'en':\n    default:\n      return defaultWizardTemplates;\n  }\n}\n\n/**\n * Helper function to get friendly null value\n * @param path - Dot-notation path to the config field\n * @returns Friendly message for null value\n */\nexport function getFriendlyNullValue(path: string): string {\n  return friendlyNullValues[path] || friendlyNullValues['default'];\n}\n\n/**\n * Template builder for wizard steps\n * Allows for dynamic construction of wizard content\n */\nexport class WizardTemplateBuilder {\n  private templates: WizardTemplates;\n  \n  constructor(language: string = 'en') {\n    this.templates = getWizardTemplates(language);\n  }\n  \n  /**\n   * Build the complete wizard text\n   */\n  buildWizardText(currentConfig: any): string {\n    const parts: string[] = [\n      this.templates.title,\n      '',\n      this.buildCurrentConfig(currentConfig),\n      '',\n      this.buildSteps(currentConfig),\n      '',\n      this.buildInstructions(),\n      '',\n      this.templates.footer,\n    ];\n    \n    return parts.join('\\n');\n  }\n  \n  /**\n   * Build current configuration section\n   */\n  private buildCurrentConfig(config: any): string {\n    return `${this.templates.currentConfigHeader}\n\\`\\`\\`yaml\n${this.formatConfigAsYaml(config)}\n\\`\\`\\``;\n  }\n  \n  /**\n   * Build all wizard steps\n   */\n  private buildSteps(config: any): string {\n    const steps = [];\n    \n    // User Identity\n    const userStep = this.templates.steps.userIdentity;\n    steps.push(this.formatStep(userStep, config.user?.username));\n    \n    // GitHub Integration\n    const githubStep = this.templates.steps.githubIntegration;\n    steps.push(this.formatStep(githubStep, config.github?.auth_token));\n    \n    // Portfolio Sync\n    const portfolioStep = this.templates.steps.portfolioSync;\n    steps.push(this.formatStep(portfolioStep, config.portfolio?.auto_sync));\n    \n    // Display Preferences\n    const displayStep = this.templates.steps.displayPreferences;\n    steps.push(this.formatStep(displayStep, config.indicator?.enabled));\n    \n    return steps.join('\\n\\n');\n  }\n  \n  /**\n   * Format a single wizard step\n   */\n  private formatStep(step: WizardStep, currentValue: any): string {\n    const lines = [\n      step.title,\n      step.description,\n    ];\n    \n    for (const instruction of step.instructions) {\n      lines.push(`- ${instruction}`);\n    }\n    \n    lines.push(`- Current: ${step.currentValue(currentValue)}`);\n    \n    return lines.join('\\n');\n  }\n  \n  /**\n   * Build instruction options\n   */\n  private buildInstructions(): string {\n    return [\n      this.templates.instructions.quick,\n      this.templates.instructions.detailed,\n      this.templates.instructions.skip,\n    ].join('\\n');\n  }\n  \n  /**\n   * Format config as YAML (stub - would use actual yaml library)\n   */\n  private formatConfigAsYaml(config: any): string {\n    // This would use the actual yaml.dump with friendly values\n    // For now, return a placeholder\n    return 'user:\\n  username: (not set)\\n  email: (optional)';\n  }\n}"]}