@dollhousemcp/mcp-server 1.7.2 → 1.7.3

package/dist/portfolio/PortfolioSyncManager.js

@@ -0,0 +1,818 @@
+/**
+ * PortfolioSyncManager - Handles synchronization between local and GitHub portfolios
+ *
+ * Features:
+ * - Download elements from GitHub portfolio
+ * - Upload elements with consent
+ * - Version comparison and diff viewing
+ * - Privacy-first with explicit permissions
+ * - Conflict resolution strategies
+ * - Bulk operations with configuration checks
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import { logger } from '../utils/logger.js';
+import { ConfigManager } from '../config/ConfigManager.js';
+import { PortfolioManager } from './PortfolioManager.js';
+import { PortfolioRepoManager } from './PortfolioRepoManager.js';
+import { GitHubPortfolioIndexer } from './GitHubPortfolioIndexer.js';
+import { TokenManager } from '../security/tokenManager.js';
+import { ContentValidator } from '../security/contentValidator.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { ElementType } from './types.js';
+import { ElementStatus } from '../types/elements/IElement.js';
+export class PortfolioSyncManager {
+    configManager;
+    portfolioManager;
+    repoManager;
+    indexer;
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.repoManager = new PortfolioRepoManager();
+        this.indexer = GitHubPortfolioIndexer.getInstance();
+    }
+    /**
+     * Main handler for sync operations
+     */
+    async handleSyncOperation(params) {
+        try {
+            // Check if sync is enabled in config
+            const config = this.configManager.getConfig();
+            if (!config.sync.enabled && params.operation !== 'list-remote') {
+                return {
+                    success: false,
+                    message: 'Sync is disabled. Enable it with: dollhouse_config --action update --setting sync.enabled --value true'
+                };
+            }
+            // Check bulk permissions
+            if (params.bulk) {
+                const bulkAllowed = this.isBulkOperationAllowed(params.operation, config);
+                if (!bulkAllowed.allowed) {
+                    return {
+                        success: false,
+                        message: bulkAllowed.message
+                    };
+                }
+            }
+            // Handle operations
+            switch (params.operation) {
+                case 'list-remote':
+                    return await this.listRemoteElements(params.element_type);
+                case 'download':
+                    if (params.bulk) {
+                        return await this.bulkDownload(params.element_type, params.confirm);
+                    }
+                    else if (params.element_name) {
+                        return await this.downloadElement(params.element_name, params.element_type, params.version, params.force);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            message: 'Element name required for individual download'
+                        };
+                    }
+                case 'upload':
+                    if (params.bulk) {
+                        return await this.bulkUpload(params.element_type, params.confirm);
+                    }
+                    else if (params.element_name) {
+                        return await this.uploadElement(params.element_name, params.element_type, params.confirm);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            message: 'Element name required for individual upload'
+                        };
+                    }
+                case 'compare':
+                    if (params.element_name && params.element_type) {
+                        return await this.compareVersions(params.element_name, params.element_type, params.show_diff);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            message: 'Element name and type required for comparison'
+                        };
+                    }
+                default:
+                    return {
+                        success: false,
+                        message: `Unknown operation: ${params.operation}`
+                    };
+            }
+        }
+        catch (error) {
+            logger.error('Sync operation failed', {
+                operation: params.operation,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return {
+                success: false,
+                message: `Sync operation failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Check if bulk operation is allowed
+     */
+    isBulkOperationAllowed(operation, config) {
+        if (operation === 'download' && !config.sync.bulk.download_enabled) {
+            return {
+                allowed: false,
+                message: 'Bulk download is disabled. Enable with: dollhouse_config --action update --setting sync.bulk.download_enabled --value true'
+            };
+        }
+        if (operation === 'upload' && !config.sync.bulk.upload_enabled) {
+            return {
+                allowed: false,
+                message: 'Bulk upload is disabled. Enable with: dollhouse_config --action update --setting sync.bulk.upload_enabled --value true'
+            };
+        }
+        return { allowed: true, message: '' };
+    }
+    /**
+     * List elements available in GitHub portfolio
+     */
+    async listRemoteElements(filterType) {
+        try {
+            // Get GitHub token
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (!token) {
+                return {
+                    success: false,
+                    message: 'GitHub authentication required. Use setup_github_auth first.'
+                };
+            }
+            this.repoManager.setToken(token);
+            // Get index of GitHub portfolio
+            const index = await this.indexer.getIndex();
+            if (!index || index.totalElements === 0) {
+                return {
+                    success: true,
+                    message: 'No elements found in GitHub portfolio',
+                    elements: []
+                };
+            }
+            // Format elements for display
+            const elements = [];
+            for (const [type, entries] of index.elements) {
+                // Skip if filtering by type and this isn't the requested type
+                if (filterType && type !== filterType) {
+                    continue;
+                }
+                for (const entry of entries) {
+                    elements.push({
+                        name: entry.name,
+                        type: type,
+                        remoteVersion: entry.version,
+                        status: 'unchanged',
+                        action: 'download'
+                    });
+                }
+            }
+            return {
+                success: true,
+                message: `Found ${elements.length} elements in GitHub portfolio`,
+                elements
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to list remote elements: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Download a specific element from GitHub
+     */
+    async downloadElement(elementName, elementType, version, force) {
+        try {
+            const config = this.configManager.getConfig();
+            // Validate element name
+            const validation = UnicodeValidator.normalize(elementName);
+            if (!validation.isValid) {
+                return {
+                    success: false,
+                    message: `Invalid element name: ${validation.detectedIssues?.[0] || 'unknown error'}`
+                };
+            }
+            // Get token and set it
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (!token) {
+                return {
+                    success: false,
+                    message: 'GitHub authentication required'
+                };
+            }
+            this.repoManager.setToken(token);
+            // Get GitHub index
+            const index = await this.indexer.getIndex();
+            // Find the element - first try exact match, then fuzzy match
+            const entries = index.elements.get(elementType) || [];
+            let entry = entries.find(e => e.name === elementName);
+            // If exact match not found, try fuzzy matching
+            if (!entry) {
+                // Try case-insensitive exact match first
+                entry = entries.find(e => e.name.toLowerCase() === elementName.toLowerCase());
+                // If still not found, try fuzzy matching
+                if (!entry) {
+                    const fuzzyMatch = this.findFuzzyMatch(elementName, entries);
+                    if (fuzzyMatch) {
+                        logger.info(`Fuzzy match found: '${elementName}' matched to '${fuzzyMatch.name}'`);
+                        entry = fuzzyMatch;
+                    }
+                }
+            }
+            if (!entry) {
+                // Generate helpful suggestions
+                const suggestions = this.getSuggestions(elementName, entries);
+                const suggestionText = suggestions.length > 0
+                    ? `\n\nDid you mean one of these?\n${suggestions.map(s => `  • ${s.name}`).join('\n')}`
+                    : '';
+                return {
+                    success: false,
+                    message: `Element '${elementName}' (${elementType}) not found in GitHub portfolio${suggestionText}`
+                };
+            }
+            // Check for local conflicts
+            const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);
+            let hasLocalVersion = false;
+            let localContent = null;
+            try {
+                localContent = await fs.readFile(localPath, 'utf-8');
+                hasLocalVersion = true;
+            }
+            catch {
+                // No local version exists
+            }
+            // Download the element
+            const response = await fetch(entry.downloadUrl, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/vnd.github.v3.raw'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to download: ${response.statusText}`);
+            }
+            const remoteContent = await response.text();
+            // Validate content security
+            const validationResult = ContentValidator.validateAndSanitize(remoteContent);
+            if (!validationResult.isValid && validationResult.severity === 'critical') {
+                return {
+                    success: false,
+                    message: `Security issue detected in remote content: ${validationResult.detectedPatterns?.join(', ')}`
+                };
+            }
+            // Check if content is different
+            if (hasLocalVersion && localContent) {
+                const localHash = createHash('sha256').update(localContent).digest('hex');
+                const remoteHash = createHash('sha256').update(remoteContent).digest('hex');
+                if (localHash === remoteHash) {
+                    return {
+                        success: true,
+                        message: `Element '${elementName}' is already up to date`
+                    };
+                }
+                // Show confirmation for overwrite unless force flag is set
+                if (config.sync.individual.require_confirmation && !force) {
+                    const diff = await this.generateDiff(localContent, remoteContent);
+                    return {
+                        success: false,
+                        message: `Local version exists. Please confirm download will overwrite:\n\n${diff}\n\nTo proceed, use --force flag`,
+                        data: { requiresConfirmation: true }
+                    };
+                }
+            }
+            // Save the element
+            await fs.mkdir(path.dirname(localPath), { recursive: true });
+            await fs.writeFile(localPath, remoteContent, 'utf-8');
+            logger.info('Element downloaded from GitHub', {
+                element: elementName,
+                type: elementType,
+                version: entry.version
+            });
+            return {
+                success: true,
+                message: `Successfully downloaded '${elementName}' (${elementType}) from GitHub portfolio`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to download element: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Upload a specific element to GitHub
+     */
+    async uploadElement(elementName, elementType, confirm) {
+        try {
+            const config = this.configManager.getConfig();
+            // Check for local element
+            const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);
+            let content;
+            try {
+                content = await fs.readFile(localPath, 'utf-8');
+            }
+            catch {
+                return {
+                    success: false,
+                    message: `Element '${elementName}' (${elementType}) not found locally`
+                };
+            }
+            // Check privacy metadata
+            const parsed = SecureYamlParser.parse(content, {
+                maxYamlSize: 64 * 1024,
+                validateContent: false,
+                validateFields: false
+            });
+            if (parsed.data?.privacy?.local_only === true) {
+                return {
+                    success: false,
+                    message: `Element '${elementName}' is marked as local-only and cannot be uploaded`
+                };
+            }
+            // Validate content security
+            const validationResult = ContentValidator.validateAndSanitize(content);
+            if (!validationResult.isValid && validationResult.severity === 'critical') {
+                return {
+                    success: false,
+                    message: `Security issue detected: ${validationResult.detectedPatterns?.join(', ')}`
+                };
+            }
+            // Scan for sensitive content if configured
+            if (config.sync.privacy.scan_for_secrets) {
+                logger.debug('Scanning for secrets before upload');
+                // Implement actual secret scanning
+                const secretPatterns = [
+                    /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi,
+                    /secret\s*[:=]\s*['"][^'"]+['"]/gi,
+                    /password\s*[:=]\s*['"][^'"]+['"]/gi,
+                    /token\s*[:=]\s*['"][^'"]+['"]/gi,
+                    /private[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi
+                ];
+                for (const pattern of secretPatterns) {
+                    if (pattern.test(content)) {
+                        return {
+                            success: false,
+                            message: `Potential secret detected in content. Please review and remove sensitive information before uploading.`
+                        };
+                    }
+                }
+            }
+            // Get confirmation if required (unless already confirmed)
+            if (config.sync.individual.require_confirmation && !confirm) {
+                return {
+                    success: false,
+                    message: `Please confirm upload of '${elementName}' (${elementType}) to GitHub.\n\nContent preview:\n${content.substring(0, 500)}...\n\nTo proceed, use --confirm flag`,
+                    data: { requiresConfirmation: true }
+                };
+            }
+            // Get token and validate
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (!token) {
+                return {
+                    success: false,
+                    message: 'GitHub authentication required'
+                };
+            }
+            // Create an IElement object for the PortfolioRepoManager
+            const element = {
+                id: `${elementType}_${elementName}_${Date.now()}`,
+                type: elementType,
+                version: parsed.data?.version || '1.0.0',
+                metadata: {
+                    name: elementName,
+                    description: parsed.data?.description || '',
+                    author: parsed.data?.author || 'unknown',
+                    created: parsed.data?.created || new Date().toISOString(),
+                    modified: new Date().toISOString(),
+                    tags: parsed.data?.tags || [],
+                    custom: parsed.data
+                },
+                validate: () => ({ valid: true, errors: [], warnings: [] }),
+                serialize: () => content,
+                deserialize: () => { },
+                getStatus: () => ElementStatus.ACTIVE
+            };
+            // Use PortfolioRepoManager to upload
+            this.repoManager.setToken(token);
+            try {
+                const url = await this.repoManager.saveElement(element, true); // consent is true since we've already checked
+                logger.info('Element uploaded to GitHub', {
+                    element: elementName,
+                    type: elementType,
+                    url
+                });
+                return {
+                    success: true,
+                    message: `Successfully uploaded '${elementName}' (${elementType}) to GitHub portfolio`,
+                    data: { url }
+                };
+            }
+            catch (uploadError) {
+                // Handle specific errors
+                if (uploadError instanceof Error && uploadError.message.includes('repository does not exist')) {
+                    return {
+                        success: false,
+                        message: `GitHub portfolio repository not found. Please initialize it first using init_portfolio tool.`
+                    };
+                }
+                throw uploadError;
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to upload element: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Compare local and remote versions
+     */
+    async compareVersions(elementName, elementType, showDiff) {
+        try {
+            // Get local version
+            const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);
+            let localContent = null;
+            let localVersion = null;
+            try {
+                localContent = await fs.readFile(localPath, 'utf-8');
+                const parsed = SecureYamlParser.parse(localContent, {
+                    maxYamlSize: 64 * 1024,
+                    validateContent: false,
+                    validateFields: false
+                });
+                localVersion = {
+                    version: parsed.data?.version || '1.0.0',
+                    timestamp: new Date(parsed.data?.updated || parsed.data?.created || Date.now()),
+                    author: parsed.data?.author || 'unknown',
+                    hash: createHash('sha256').update(localContent).digest('hex'),
+                    size: Buffer.byteLength(localContent),
+                    source: 'local'
+                };
+            }
+            catch {
+                // No local version
+            }
+            // Get remote version
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (!token) {
+                return {
+                    success: false,
+                    message: 'GitHub authentication required'
+                };
+            }
+            const index = await this.indexer.getIndex();
+            const entries = index.elements.get(elementType) || [];
+            const entry = entries.find(e => e.name === elementName);
+            let remoteVersion = null;
+            let remoteContent = null;
+            if (entry) {
+                const response = await fetch(entry.downloadUrl, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Accept': 'application/vnd.github.v3.raw'
+                    }
+                });
+                if (response.ok) {
+                    remoteContent = await response.text();
+                    remoteVersion = {
+                        version: entry.version || '1.0.0',
+                        timestamp: entry.lastModified,
+                        author: entry.author || 'unknown',
+                        hash: createHash('sha256').update(remoteContent).digest('hex'),
+                        size: entry.size,
+                        source: 'remote'
+                    };
+                }
+            }
+            // Build comparison result
+            const result = {
+                element: elementName,
+                type: elementType,
+                local: localVersion,
+                remote: remoteVersion
+            };
+            if (localVersion && remoteVersion) {
+                result.status = localVersion.hash === remoteVersion.hash ? 'identical' : 'different';
+                if (showDiff && localContent && remoteContent && result.status === 'different') {
+                    result.diff = await this.generateDiff(localContent, remoteContent);
+                }
+            }
+            else if (localVersion && !remoteVersion) {
+                result.status = 'local-only';
+            }
+            else if (!localVersion && remoteVersion) {
+                result.status = 'remote-only';
+            }
+            else {
+                result.status = 'not-found';
+            }
+            return {
+                success: true,
+                message: `Version comparison for '${elementName}' (${elementType})`,
+                data: result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to compare versions: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Bulk download elements
+     */
+    async bulkDownload(elementType, confirm) {
+        const config = this.configManager.getConfig();
+        if (!config.sync.bulk.download_enabled) {
+            return {
+                success: false,
+                message: 'Bulk download is not enabled in configuration'
+            };
+        }
+        // Get list of remote elements
+        const remoteResult = await this.listRemoteElements();
+        if (!remoteResult.success || !remoteResult.elements) {
+            return remoteResult;
+        }
+        // Filter by type if specified
+        let elementsToDownload = remoteResult.elements;
+        if (elementType) {
+            elementsToDownload = elementsToDownload.filter(e => e.type === elementType);
+        }
+        if (elementsToDownload.length === 0) {
+            return {
+                success: true,
+                message: 'No elements to download',
+                elements: []
+            };
+        }
+        // Show preview if required (unless already confirmed)
+        if (config.sync.bulk.require_preview && !confirm) {
+            return {
+                success: false,
+                message: `Bulk download preview:\n\n${elementsToDownload.length} elements will be downloaded:\n${elementsToDownload.map(e => `- ${e.name} (${e.type})`).join('\n')}\n\nTo proceed, use --confirm flag`,
+                data: { requiresConfirmation: true },
+                elements: elementsToDownload
+            };
+        }
+        // Perform actual bulk download
+        const results = {
+            downloaded: [],
+            skipped: [],
+            failed: []
+        };
+        for (const element of elementsToDownload) {
+            try {
+                const result = await this.downloadElement(element.name, element.type, undefined, true); // force=true to skip individual confirmations
+                if (result.success) {
+                    results.downloaded.push(element.name);
+                }
+                else if (result.message?.includes('already up to date')) {
+                    results.skipped.push(element.name);
+                }
+                else {
+                    results.failed.push({ name: element.name, error: result.message || 'Unknown error' });
+                }
+            }
+            catch (error) {
+                results.failed.push({
+                    name: element.name,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        // Build summary message
+        let message = `Bulk download complete:\n`;
+        message += `- Downloaded: ${results.downloaded.length} elements\n`;
+        message += `- Skipped (up to date): ${results.skipped.length} elements\n`;
+        message += `- Failed: ${results.failed.length} elements`;
+        if (results.failed.length > 0) {
+            message += `\n\nFailed downloads:\n${results.failed.map(f => `- ${f.name}: ${f.error}`).join('\n')}`;
+        }
+        return {
+            success: results.failed.length === 0,
+            message,
+            data: results
+        };
+    }
+    /**
+     * Bulk upload elements
+     */
+    async bulkUpload(elementType, confirm) {
+        const config = this.configManager.getConfig();
+        if (!config.sync.bulk.upload_enabled) {
+            return {
+                success: false,
+                message: 'Bulk upload is not enabled in configuration'
+            };
+        }
+        // Get list of local elements
+        const types = elementType ? [elementType] : [
+            ElementType.PERSONA,
+            ElementType.SKILL,
+            ElementType.TEMPLATE,
+            ElementType.AGENT,
+            ElementType.MEMORY,
+            ElementType.ENSEMBLE
+        ];
+        const localElements = [];
+        for (const type of types) {
+            const dir = this.portfolioManager.getElementDir(type);
+            try {
+                const files = await fs.readdir(dir);
+                for (const file of files) {
+                    if (file.endsWith('.md')) {
+                        localElements.push({
+                            name: file.replace('.md', ''),
+                            type,
+                            path: path.join(dir, file)
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Directory may not exist yet
+                logger.debug(`Directory for ${type} does not exist yet`);
+            }
+        }
+        if (localElements.length === 0) {
+            return {
+                success: true,
+                message: 'No local elements to upload',
+                elements: []
+            };
+        }
+        // Show preview if required (unless already confirmed)
+        if (config.sync.bulk.require_preview && !confirm) {
+            // Convert to SyncElementInfo format for preview
+            const previewElements = localElements.map(e => ({
+                name: e.name,
+                type: e.type,
+                status: 'local-only',
+                action: 'upload'
+            }));
+            return {
+                success: false,
+                message: `Bulk upload preview:\n\n${localElements.length} elements will be uploaded:\n${localElements.map(e => `- ${e.name} (${e.type})`).join('\n')}\n\nTo proceed, use --confirm flag`,
+                data: { requiresConfirmation: true },
+                elements: previewElements
+            };
+        }
+        // Perform actual bulk upload
+        const results = {
+            uploaded: [],
+            skipped: [],
+            failed: []
+        };
+        for (const element of localElements) {
+            try {
+                const result = await this.uploadElement(element.name, element.type, true); // confirm=true to skip individual confirmations
+                if (result.success) {
+                    results.uploaded.push(element.name);
+                }
+                else if (result.message?.includes('local-only')) {
+                    results.skipped.push(element.name);
+                }
+                else {
+                    results.failed.push({ name: element.name, error: result.message || 'Unknown error' });
+                }
+            }
+            catch (error) {
+                results.failed.push({
+                    name: element.name,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        // Build summary message
+        let message = `Bulk upload complete:\n`;
+        message += `- Uploaded: ${results.uploaded.length} elements\n`;
+        message += `- Skipped (local-only): ${results.skipped.length} elements\n`;
+        message += `- Failed: ${results.failed.length} elements`;
+        if (results.failed.length > 0) {
+            message += `\n\nFailed uploads:\n${results.failed.map(f => `- ${f.name}: ${f.error}`).join('\n')}`;
+        }
+        return {
+            success: results.failed.length === 0,
+            message,
+            data: results
+        };
+    }
+    /**
+     * Generate diff between two content versions
+     */
+    async generateDiff(local, remote) {
+        // Simple line-based diff for now
+        const localLines = local.split('\n');
+        const remoteLines = remote.split('\n');
+        let diff = '';
+        const maxLines = Math.max(localLines.length, remoteLines.length);
+        for (let i = 0; i < maxLines && i < 10; i++) { // Show first 10 lines of diff
+            const localLine = localLines[i] || '';
+            const remoteLine = remoteLines[i] || '';
+            if (localLine !== remoteLine) {
+                if (localLine && !remoteLine) {
+                    diff += `- ${localLine}\n`;
+                }
+                else if (!localLine && remoteLine) {
+                    diff += `+ ${remoteLine}\n`;
+                }
+                else {
+                    diff += `- ${localLine}\n`;
+                    diff += `+ ${remoteLine}\n`;
+                }
+            }
+        }
+        if (maxLines > 10) {
+            diff += `\n... ${maxLines - 10} more lines ...`;
+        }
+        return diff || 'No differences found';
+    }
+    /**
+     * Find a fuzzy match for an element name
+     */
+    findFuzzyMatch(searchName, entries) {
+        const search = searchName.toLowerCase().replace(/[-_]/g, '');
+        let bestMatch = null;
+        let bestScore = 0;
+        for (const entry of entries) {
+            // Normalize the entry name for comparison
+            const normalized = entry.name.toLowerCase().replace(/[-_]/g, '');
+            // Calculate similarity score
+            const score = this.calculateSimilarity(search, normalized);
+            if (score > bestScore && score > 0.5) { // Minimum threshold of 0.5
+                bestScore = score;
+                bestMatch = entry;
+            }
+        }
+        return bestMatch;
+    }
+    /**
+     * Get suggestions for similar element names
+     */
+    getSuggestions(searchName, entries) {
+        const search = searchName.toLowerCase().replace(/[-_]/g, '');
+        const scored = [];
+        for (const entry of entries) {
+            const normalized = entry.name.toLowerCase().replace(/[-_]/g, '');
+            const score = this.calculateSimilarity(search, normalized);
+            if (score > 0.3) { // Lower threshold for suggestions
+                scored.push({ entry, score });
+            }
+        }
+        // Sort by score and return top 5
+        return scored
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 5)
+            .map(s => ({ name: s.entry.name }));
+    }
+    /**
+     * Calculate similarity between two strings
+     * Returns a score between 0 and 1
+     */
+    calculateSimilarity(a, b) {
+        // Exact match
+        if (a === b)
+            return 1.0;
+        // One contains the other
+        if (a.includes(b) || b.includes(a))
+            return 0.8;
+        // Calculate word overlap
+        const wordsA = a.split(/[^a-z0-9]+/);
+        const wordsB = b.split(/[^a-z0-9]+/);
+        let matches = 0;
+        for (const wordA of wordsA) {
+            if (wordA && wordsB.some(wordB => wordB === wordA)) {
+                matches++;
+            }
+        }
+        if (matches > 0) {
+            const overlap = (matches * 2) / (wordsA.length + wordsB.length);
+            return Math.max(0.6, overlap); // At least 0.6 for any word match
+        }
+        // Check for partial matches
+        for (const wordA of wordsA) {
+            for (const wordB of wordsB) {
+                if (wordA.length > 3 && wordB.length > 3) {
+                    if (wordA.includes(wordB) || wordB.includes(wordA)) {
+                        return 0.5;
+                    }
+                }
+            }
+        }
+        // No significant similarity
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioSyncManager.js","sourceRoot":"","sources":["../../src/portfolio/PortfolioSyncManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PortfolioSyncManager - Handles synchronization between local and GitHub portfolios\n * \n * Features:\n * - Download elements from GitHub portfolio\n * - Upload elements with consent\n * - Version comparison and diff viewing\n * - Privacy-first with explicit permissions\n * - Conflict resolution strategies\n * - Bulk operations with configuration checks\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { createHash } from 'crypto';\nimport { logger } from '../utils/logger.js';\nimport { ConfigManager, DollhouseConfig } from '../config/ConfigManager.js';\nimport { PortfolioManager } from './PortfolioManager.js';\nimport { PortfolioRepoManager } from './PortfolioRepoManager.js';\nimport { GitHubPortfolioIndexer, GitHubIndexEntry } from './GitHubPortfolioIndexer.js';\nimport { TokenManager } from '../security/tokenManager.js';\nimport { ContentValidator } from '../security/contentValidator.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { ElementType } from './types.js';\nimport { IElement, ElementStatus } from '../types/elements/IElement.js';\n\nexport interface SyncOperation {\n  operation: 'download' | 'upload' | 'compare' | 'list-remote';\n  element_name?: string;\n  element_type?: ElementType;\n  bulk?: boolean;\n  version?: string;\n  show_diff?: boolean;\n  force?: boolean;\n  confirm?: boolean;\n}\n\nexport interface SyncResult {\n  success: boolean;\n  message: string;\n  data?: any;\n  elements?: SyncElementInfo[];\n  conflicts?: ConflictInfo[];\n}\n\nexport interface SyncElementInfo {\n  name: string;\n  type: ElementType;\n  localVersion?: string;\n  remoteVersion?: string;\n  status: 'new' | 'updated' | 'conflict' | 'unchanged' | 'local-only';\n  action?: 'download' | 'upload' | 'skip';\n}\n\nexport interface ConflictInfo {\n  element: string;\n  type: ElementType;\n  localVersion: string;\n  remoteVersion: string;\n  localModified: Date;\n  remoteModified: Date;\n  resolution?: 'local' | 'remote' | 'manual';\n}\n\nexport interface VersionInfo {\n  version: string;\n  timestamp: Date;\n  author: string;\n  hash: string;\n  size: number;\n  source: 'local' | 'remote';\n}\n\nexport interface ElementDiff {\n  element: string;\n  type: ElementType;\n  changes: {\n    metadata?: {\n      field: string;\n      oldValue: any;\n      newValue: any;\n    }[];\n    content?: {\n      additions: number;\n      deletions: number;\n      diff: string;\n    };\n  };\n}\n\nexport class PortfolioSyncManager {\n  private configManager: ConfigManager;\n  private portfolioManager: PortfolioManager;\n  private repoManager: PortfolioRepoManager;\n  private indexer: GitHubPortfolioIndexer;\n  \n  constructor() {\n    this.configManager = ConfigManager.getInstance();\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.repoManager = new PortfolioRepoManager();\n    this.indexer = GitHubPortfolioIndexer.getInstance();\n  }\n  \n  /**\n   * Main handler for sync operations\n   */\n  public async handleSyncOperation(params: SyncOperation): Promise<SyncResult> {\n    try {\n      // Check if sync is enabled in config\n      const config = this.configManager.getConfig();\n      if (!config.sync.enabled && params.operation !== 'list-remote') {\n        return {\n          success: false,\n          message: 'Sync is disabled. Enable it with: dollhouse_config --action update --setting sync.enabled --value true'\n        };\n      }\n      \n      // Check bulk permissions\n      if (params.bulk) {\n        const bulkAllowed = this.isBulkOperationAllowed(params.operation, config);\n        if (!bulkAllowed.allowed) {\n          return {\n            success: false,\n            message: bulkAllowed.message\n          };\n        }\n      }\n      \n      // Handle operations\n      switch (params.operation) {\n        case 'list-remote':\n          return await this.listRemoteElements(params.element_type);\n          \n        case 'download':\n          if (params.bulk) {\n            return await this.bulkDownload(params.element_type, params.confirm);\n          } else if (params.element_name) {\n            return await this.downloadElement(\n              params.element_name,\n              params.element_type!,\n              params.version,\n              params.force\n            );\n          } else {\n            return {\n              success: false,\n              message: 'Element name required for individual download'\n            };\n          }\n          \n        case 'upload':\n          if (params.bulk) {\n            return await this.bulkUpload(params.element_type, params.confirm);\n          } else if (params.element_name) {\n            return await this.uploadElement(\n              params.element_name,\n              params.element_type!,\n              params.confirm\n            );\n          } else {\n            return {\n              success: false,\n              message: 'Element name required for individual upload'\n            };\n          }\n          \n        case 'compare':\n          if (params.element_name && params.element_type) {\n            return await this.compareVersions(\n              params.element_name,\n              params.element_type,\n              params.show_diff\n            );\n          } else {\n            return {\n              success: false,\n              message: 'Element name and type required for comparison'\n            };\n          }\n          \n        default:\n          return {\n            success: false,\n            message: `Unknown operation: ${params.operation}`\n          };\n      }\n    } catch (error) {\n      logger.error('Sync operation failed', {\n        operation: params.operation,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      \n      return {\n        success: false,\n        message: `Sync operation failed: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Check if bulk operation is allowed\n   */\n  private isBulkOperationAllowed(operation: string, config: DollhouseConfig): { allowed: boolean; message: string } {\n    if (operation === 'download' && !config.sync.bulk.download_enabled) {\n      return {\n        allowed: false,\n        message: 'Bulk download is disabled. Enable with: dollhouse_config --action update --setting sync.bulk.download_enabled --value true'\n      };\n    }\n    \n    if (operation === 'upload' && !config.sync.bulk.upload_enabled) {\n      return {\n        allowed: false,\n        message: 'Bulk upload is disabled. Enable with: dollhouse_config --action update --setting sync.bulk.upload_enabled --value true'\n      };\n    }\n    \n    return { allowed: true, message: '' };\n  }\n  \n  /**\n   * List elements available in GitHub portfolio\n   */\n  private async listRemoteElements(filterType?: ElementType): Promise<SyncResult> {\n    try {\n      // Get GitHub token\n      const token = await TokenManager.getGitHubTokenAsync();\n      if (!token) {\n        return {\n          success: false,\n          message: 'GitHub authentication required. Use setup_github_auth first.'\n        };\n      }\n      \n      this.repoManager.setToken(token);\n      \n      // Get index of GitHub portfolio\n      const index = await this.indexer.getIndex();\n      \n      if (!index || index.totalElements === 0) {\n        return {\n          success: true,\n          message: 'No elements found in GitHub portfolio',\n          elements: []\n        };\n      }\n      \n      // Format elements for display\n      const elements: SyncElementInfo[] = [];\n      \n      for (const [type, entries] of index.elements) {\n        // Skip if filtering by type and this isn't the requested type\n        if (filterType && type !== filterType) {\n          continue;\n        }\n        \n        for (const entry of entries) {\n          elements.push({\n            name: entry.name,\n            type: type,\n            remoteVersion: entry.version,\n            status: 'unchanged',\n            action: 'download'\n          });\n        }\n      }\n      \n      return {\n        success: true,\n        message: `Found ${elements.length} elements in GitHub portfolio`,\n        elements\n      };\n      \n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to list remote elements: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Download a specific element from GitHub\n   */\n  private async downloadElement(\n    elementName: string,\n    elementType: ElementType,\n    version?: string,\n    force?: boolean\n  ): Promise<SyncResult> {\n    try {\n      const config = this.configManager.getConfig();\n      \n      // Validate element name\n      const validation = UnicodeValidator.normalize(elementName);\n      if (!validation.isValid) {\n        return {\n          success: false,\n          message: `Invalid element name: ${validation.detectedIssues?.[0] || 'unknown error'}`\n        };\n      }\n      \n      // Get token and set it\n      const token = await TokenManager.getGitHubTokenAsync();\n      if (!token) {\n        return {\n          success: false,\n          message: 'GitHub authentication required'\n        };\n      }\n      \n      this.repoManager.setToken(token);\n      \n      // Get GitHub index\n      const index = await this.indexer.getIndex();\n      \n      // Find the element - first try exact match, then fuzzy match\n      const entries = index.elements.get(elementType) || [];\n      let entry = entries.find(e => e.name === elementName);\n      \n      // If exact match not found, try fuzzy matching\n      if (!entry) {\n        // Try case-insensitive exact match first\n        entry = entries.find(e => e.name.toLowerCase() === elementName.toLowerCase());\n        \n        // If still not found, try fuzzy matching\n        if (!entry) {\n          const fuzzyMatch = this.findFuzzyMatch(elementName, entries);\n          if (fuzzyMatch) {\n            logger.info(`Fuzzy match found: '${elementName}' matched to '${fuzzyMatch.name}'`);\n            entry = fuzzyMatch;\n          }\n        }\n      }\n      \n      if (!entry) {\n        // Generate helpful suggestions\n        const suggestions = this.getSuggestions(elementName, entries);\n        const suggestionText = suggestions.length > 0 \n          ? `\\n\\nDid you mean one of these?\\n${suggestions.map(s => `  • ${s.name}`).join('\\n')}`\n          : '';\n        \n        return {\n          success: false,\n          message: `Element '${elementName}' (${elementType}) not found in GitHub portfolio${suggestionText}`\n        };\n      }\n      \n      // Check for local conflicts\n      const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);\n      let hasLocalVersion = false;\n      let localContent: string | null = null;\n      \n      try {\n        localContent = await fs.readFile(localPath, 'utf-8');\n        hasLocalVersion = true;\n      } catch {\n        // No local version exists\n      }\n      \n      // Download the element\n      const response = await fetch(entry.downloadUrl, {\n        headers: {\n          'Authorization': `Bearer ${token}`,\n          'Accept': 'application/vnd.github.v3.raw'\n        }\n      });\n      \n      if (!response.ok) {\n        throw new Error(`Failed to download: ${response.statusText}`);\n      }\n      \n      const remoteContent = await response.text();\n      \n      // Validate content security\n      const validationResult = ContentValidator.validateAndSanitize(remoteContent);\n      if (!validationResult.isValid && validationResult.severity === 'critical') {\n        return {\n          success: false,\n          message: `Security issue detected in remote content: ${validationResult.detectedPatterns?.join(', ')}`\n        };\n      }\n      \n      // Check if content is different\n      if (hasLocalVersion && localContent) {\n        const localHash = createHash('sha256').update(localContent).digest('hex');\n        const remoteHash = createHash('sha256').update(remoteContent).digest('hex');\n        \n        if (localHash === remoteHash) {\n          return {\n            success: true,\n            message: `Element '${elementName}' is already up to date`\n          };\n        }\n        \n        // Show confirmation for overwrite unless force flag is set\n        if (config.sync.individual.require_confirmation && !force) {\n          const diff = await this.generateDiff(localContent, remoteContent);\n          \n          return {\n            success: false,\n            message: `Local version exists. Please confirm download will overwrite:\\n\\n${diff}\\n\\nTo proceed, use --force flag`,\n            data: { requiresConfirmation: true }\n          };\n        }\n      }\n      \n      // Save the element\n      await fs.mkdir(path.dirname(localPath), { recursive: true });\n      await fs.writeFile(localPath, remoteContent, 'utf-8');\n      \n      logger.info('Element downloaded from GitHub', {\n        element: elementName,\n        type: elementType,\n        version: entry.version\n      });\n      \n      return {\n        success: true,\n        message: `Successfully downloaded '${elementName}' (${elementType}) from GitHub portfolio`\n      };\n      \n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to download element: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Upload a specific element to GitHub\n   */\n  private async uploadElement(\n    elementName: string,\n    elementType: ElementType,\n    confirm?: boolean\n  ): Promise<SyncResult> {\n    try {\n      const config = this.configManager.getConfig();\n      \n      // Check for local element\n      const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);\n      \n      let content: string;\n      try {\n        content = await fs.readFile(localPath, 'utf-8');\n      } catch {\n        return {\n          success: false,\n          message: `Element '${elementName}' (${elementType}) not found locally`\n        };\n      }\n      \n      // Check privacy metadata\n      const parsed = SecureYamlParser.parse(content, {\n        maxYamlSize: 64 * 1024,\n        validateContent: false,\n        validateFields: false\n      });\n      \n      if (parsed.data?.privacy?.local_only === true) {\n        return {\n          success: false,\n          message: `Element '${elementName}' is marked as local-only and cannot be uploaded`\n        };\n      }\n      \n      // Validate content security\n      const validationResult = ContentValidator.validateAndSanitize(content);\n      if (!validationResult.isValid && validationResult.severity === 'critical') {\n        return {\n          success: false,\n          message: `Security issue detected: ${validationResult.detectedPatterns?.join(', ')}`\n        };\n      }\n      \n      // Scan for sensitive content if configured\n      if (config.sync.privacy.scan_for_secrets) {\n        logger.debug('Scanning for secrets before upload');\n        // Implement actual secret scanning\n        const secretPatterns = [\n          /api[_-]?key\\s*[:=]\\s*['\"][^'\"]+['\"]/gi,\n          /secret\\s*[:=]\\s*['\"][^'\"]+['\"]/gi,\n          /password\\s*[:=]\\s*['\"][^'\"]+['\"]/gi,\n          /token\\s*[:=]\\s*['\"][^'\"]+['\"]/gi,\n          /private[_-]?key\\s*[:=]\\s*['\"][^'\"]+['\"]/gi\n        ];\n        \n        for (const pattern of secretPatterns) {\n          if (pattern.test(content)) {\n            return {\n              success: false,\n              message: `Potential secret detected in content. Please review and remove sensitive information before uploading.`\n            };\n          }\n        }\n      }\n      \n      // Get confirmation if required (unless already confirmed)\n      if (config.sync.individual.require_confirmation && !confirm) {\n        return {\n          success: false,\n          message: `Please confirm upload of '${elementName}' (${elementType}) to GitHub.\\n\\nContent preview:\\n${content.substring(0, 500)}...\\n\\nTo proceed, use --confirm flag`,\n          data: { requiresConfirmation: true }\n        };\n      }\n      \n      // Get token and validate\n      const token = await TokenManager.getGitHubTokenAsync();\n      if (!token) {\n        return {\n          success: false,\n          message: 'GitHub authentication required'\n        };\n      }\n      \n      // Create an IElement object for the PortfolioRepoManager\n      const element: IElement = {\n        id: `${elementType}_${elementName}_${Date.now()}`,\n        type: elementType,\n        version: parsed.data?.version || '1.0.0',\n        metadata: {\n          name: elementName,\n          description: parsed.data?.description || '',\n          author: parsed.data?.author || 'unknown',\n          created: parsed.data?.created || new Date().toISOString(),\n          modified: new Date().toISOString(),\n          tags: parsed.data?.tags || [],\n          custom: parsed.data\n        },\n        validate: () => ({ valid: true, errors: [], warnings: [] }),\n        serialize: () => content,\n        deserialize: () => {},\n        getStatus: () => ElementStatus.ACTIVE\n      };\n      \n      // Use PortfolioRepoManager to upload\n      this.repoManager.setToken(token);\n      \n      try {\n        const url = await this.repoManager.saveElement(element, true); // consent is true since we've already checked\n        \n        logger.info('Element uploaded to GitHub', {\n          element: elementName,\n          type: elementType,\n          url\n        });\n        \n        return {\n          success: true,\n          message: `Successfully uploaded '${elementName}' (${elementType}) to GitHub portfolio`,\n          data: { url }\n        };\n      } catch (uploadError) {\n        // Handle specific errors\n        if (uploadError instanceof Error && uploadError.message.includes('repository does not exist')) {\n          return {\n            success: false,\n            message: `GitHub portfolio repository not found. Please initialize it first using init_portfolio tool.`\n          };\n        }\n        throw uploadError;\n      }\n      \n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to upload element: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Compare local and remote versions\n   */\n  private async compareVersions(\n    elementName: string,\n    elementType: ElementType,\n    showDiff?: boolean\n  ): Promise<SyncResult> {\n    try {\n      // Get local version\n      const localPath = this.portfolioManager.getElementPath(elementType, `${elementName}.md`);\n      let localContent: string | null = null;\n      let localVersion: VersionInfo | null = null;\n      \n      try {\n        localContent = await fs.readFile(localPath, 'utf-8');\n        const parsed = SecureYamlParser.parse(localContent, {\n          maxYamlSize: 64 * 1024,\n          validateContent: false,\n          validateFields: false\n        });\n        \n        localVersion = {\n          version: parsed.data?.version || '1.0.0',\n          timestamp: new Date(parsed.data?.updated || parsed.data?.created || Date.now()),\n          author: parsed.data?.author || 'unknown',\n          hash: createHash('sha256').update(localContent).digest('hex'),\n          size: Buffer.byteLength(localContent),\n          source: 'local'\n        };\n      } catch {\n        // No local version\n      }\n      \n      // Get remote version\n      const token = await TokenManager.getGitHubTokenAsync();\n      if (!token) {\n        return {\n          success: false,\n          message: 'GitHub authentication required'\n        };\n      }\n      \n      const index = await this.indexer.getIndex();\n      const entries = index.elements.get(elementType) || [];\n      const entry = entries.find(e => e.name === elementName);\n      \n      let remoteVersion: VersionInfo | null = null;\n      let remoteContent: string | null = null;\n      \n      if (entry) {\n        const response = await fetch(entry.downloadUrl, {\n          headers: {\n            'Authorization': `Bearer ${token}`,\n            'Accept': 'application/vnd.github.v3.raw'\n          }\n        });\n        \n        if (response.ok) {\n          remoteContent = await response.text();\n          remoteVersion = {\n            version: entry.version || '1.0.0',\n            timestamp: entry.lastModified,\n            author: entry.author || 'unknown',\n            hash: createHash('sha256').update(remoteContent).digest('hex'),\n            size: entry.size,\n            source: 'remote'\n          };\n        }\n      }\n      \n      // Build comparison result\n      const result: any = {\n        element: elementName,\n        type: elementType,\n        local: localVersion,\n        remote: remoteVersion\n      };\n      \n      if (localVersion && remoteVersion) {\n        result.status = localVersion.hash === remoteVersion.hash ? 'identical' : 'different';\n        \n        if (showDiff && localContent && remoteContent && result.status === 'different') {\n          result.diff = await this.generateDiff(localContent, remoteContent);\n        }\n      } else if (localVersion && !remoteVersion) {\n        result.status = 'local-only';\n      } else if (!localVersion && remoteVersion) {\n        result.status = 'remote-only';\n      } else {\n        result.status = 'not-found';\n      }\n      \n      return {\n        success: true,\n        message: `Version comparison for '${elementName}' (${elementType})`,\n        data: result\n      };\n      \n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to compare versions: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Bulk download elements\n   */\n  private async bulkDownload(elementType?: ElementType, confirm?: boolean): Promise<SyncResult> {\n    const config = this.configManager.getConfig();\n    \n    if (!config.sync.bulk.download_enabled) {\n      return {\n        success: false,\n        message: 'Bulk download is not enabled in configuration'\n      };\n    }\n    \n    // Get list of remote elements\n    const remoteResult = await this.listRemoteElements();\n    if (!remoteResult.success || !remoteResult.elements) {\n      return remoteResult;\n    }\n    \n    // Filter by type if specified\n    let elementsToDownload = remoteResult.elements;\n    if (elementType) {\n      elementsToDownload = elementsToDownload.filter(e => e.type === elementType);\n    }\n    \n    if (elementsToDownload.length === 0) {\n      return {\n        success: true,\n        message: 'No elements to download',\n        elements: []\n      };\n    }\n    \n    // Show preview if required (unless already confirmed)\n    if (config.sync.bulk.require_preview && !confirm) {\n      return {\n        success: false,\n        message: `Bulk download preview:\\n\\n${elementsToDownload.length} elements will be downloaded:\\n${elementsToDownload.map(e => `- ${e.name} (${e.type})`).join('\\n')}\\n\\nTo proceed, use --confirm flag`,\n        data: { requiresConfirmation: true },\n        elements: elementsToDownload\n      };\n    }\n    \n    // Perform actual bulk download\n    const results = {\n      downloaded: [] as string[],\n      skipped: [] as string[],\n      failed: [] as { name: string; error: string }[]\n    };\n    \n    for (const element of elementsToDownload) {\n      try {\n        const result = await this.downloadElement(element.name, element.type, undefined, true); // force=true to skip individual confirmations\n        if (result.success) {\n          results.downloaded.push(element.name);\n        } else if (result.message?.includes('already up to date')) {\n          results.skipped.push(element.name);\n        } else {\n          results.failed.push({ name: element.name, error: result.message || 'Unknown error' });\n        }\n      } catch (error) {\n        results.failed.push({ \n          name: element.name, \n          error: error instanceof Error ? error.message : String(error) \n        });\n      }\n    }\n    \n    // Build summary message\n    let message = `Bulk download complete:\\n`;\n    message += `- Downloaded: ${results.downloaded.length} elements\\n`;\n    message += `- Skipped (up to date): ${results.skipped.length} elements\\n`;\n    message += `- Failed: ${results.failed.length} elements`;\n    \n    if (results.failed.length > 0) {\n      message += `\\n\\nFailed downloads:\\n${results.failed.map(f => `- ${f.name}: ${f.error}`).join('\\n')}`;\n    }\n    \n    return {\n      success: results.failed.length === 0,\n      message,\n      data: results\n    };\n  }\n  \n  /**\n   * Bulk upload elements\n   */\n  private async bulkUpload(elementType?: ElementType, confirm?: boolean): Promise<SyncResult> {\n    const config = this.configManager.getConfig();\n    \n    if (!config.sync.bulk.upload_enabled) {\n      return {\n        success: false,\n        message: 'Bulk upload is not enabled in configuration'\n      };\n    }\n    \n    // Get list of local elements\n    const types = elementType ? [elementType] : [\n      ElementType.PERSONA,\n      ElementType.SKILL,\n      ElementType.TEMPLATE,\n      ElementType.AGENT,\n      ElementType.MEMORY,\n      ElementType.ENSEMBLE\n    ];\n    \n    const localElements: { name: string; type: ElementType; path: string }[] = [];\n    \n    for (const type of types) {\n      const dir = this.portfolioManager.getElementDir(type);\n      try {\n        const files = await fs.readdir(dir);\n        for (const file of files) {\n          if (file.endsWith('.md')) {\n            localElements.push({\n              name: file.replace('.md', ''),\n              type,\n              path: path.join(dir, file)\n            });\n          }\n        }\n      } catch (error) {\n        // Directory may not exist yet\n        logger.debug(`Directory for ${type} does not exist yet`);\n      }\n    }\n    \n    if (localElements.length === 0) {\n      return {\n        success: true,\n        message: 'No local elements to upload',\n        elements: []\n      };\n    }\n    \n    // Show preview if required (unless already confirmed)\n    if (config.sync.bulk.require_preview && !confirm) {\n      // Convert to SyncElementInfo format for preview\n      const previewElements: SyncElementInfo[] = localElements.map(e => ({\n        name: e.name,\n        type: e.type,\n        status: 'local-only' as const,\n        action: 'upload' as const\n      }));\n      \n      return {\n        success: false,\n        message: `Bulk upload preview:\\n\\n${localElements.length} elements will be uploaded:\\n${localElements.map(e => `- ${e.name} (${e.type})`).join('\\n')}\\n\\nTo proceed, use --confirm flag`,\n        data: { requiresConfirmation: true },\n        elements: previewElements\n      };\n    }\n    \n    // Perform actual bulk upload\n    const results = {\n      uploaded: [] as string[],\n      skipped: [] as string[],\n      failed: [] as { name: string; error: string }[]\n    };\n    \n    for (const element of localElements) {\n      try {\n        const result = await this.uploadElement(element.name, element.type, true); // confirm=true to skip individual confirmations\n        if (result.success) {\n          results.uploaded.push(element.name);\n        } else if (result.message?.includes('local-only')) {\n          results.skipped.push(element.name);\n        } else {\n          results.failed.push({ name: element.name, error: result.message || 'Unknown error' });\n        }\n      } catch (error) {\n        results.failed.push({ \n          name: element.name, \n          error: error instanceof Error ? error.message : String(error) \n        });\n      }\n    }\n    \n    // Build summary message\n    let message = `Bulk upload complete:\\n`;\n    message += `- Uploaded: ${results.uploaded.length} elements\\n`;\n    message += `- Skipped (local-only): ${results.skipped.length} elements\\n`;\n    message += `- Failed: ${results.failed.length} elements`;\n    \n    if (results.failed.length > 0) {\n      message += `\\n\\nFailed uploads:\\n${results.failed.map(f => `- ${f.name}: ${f.error}`).join('\\n')}`;\n    }\n    \n    return {\n      success: results.failed.length === 0,\n      message,\n      data: results\n    };\n  }\n  \n  /**\n   * Generate diff between two content versions\n   */\n  private async generateDiff(local: string, remote: string): Promise<string> {\n    // Simple line-based diff for now\n    const localLines = local.split('\\n');\n    const remoteLines = remote.split('\\n');\n    \n    let diff = '';\n    const maxLines = Math.max(localLines.length, remoteLines.length);\n    \n    for (let i = 0; i < maxLines && i < 10; i++) { // Show first 10 lines of diff\n      const localLine = localLines[i] || '';\n      const remoteLine = remoteLines[i] || '';\n      \n      if (localLine !== remoteLine) {\n        if (localLine && !remoteLine) {\n          diff += `- ${localLine}\\n`;\n        } else if (!localLine && remoteLine) {\n          diff += `+ ${remoteLine}\\n`;\n        } else {\n          diff += `- ${localLine}\\n`;\n          diff += `+ ${remoteLine}\\n`;\n        }\n      }\n    }\n    \n    if (maxLines > 10) {\n      diff += `\\n... ${maxLines - 10} more lines ...`;\n    }\n    \n    return diff || 'No differences found';\n  }\n  \n  /**\n   * Find a fuzzy match for an element name\n   */\n  private findFuzzyMatch(searchName: string, entries: GitHubIndexEntry[]): GitHubIndexEntry | null {\n    const search = searchName.toLowerCase().replace(/[-_]/g, '');\n    let bestMatch: typeof entries[0] | null = null;\n    let bestScore = 0;\n    \n    for (const entry of entries) {\n      // Normalize the entry name for comparison\n      const normalized = entry.name.toLowerCase().replace(/[-_]/g, '');\n      \n      // Calculate similarity score\n      const score = this.calculateSimilarity(search, normalized);\n      if (score > bestScore && score > 0.5) { // Minimum threshold of 0.5\n        bestScore = score;\n        bestMatch = entry;\n      }\n    }\n    \n    return bestMatch;\n  }\n  \n  /**\n   * Get suggestions for similar element names\n   */\n  private getSuggestions(searchName: string, entries: GitHubIndexEntry[]): Array<{name: string}> {\n    const search = searchName.toLowerCase().replace(/[-_]/g, '');\n    const scored: Array<{entry: typeof entries[0]; score: number}> = [];\n    \n    for (const entry of entries) {\n      const normalized = entry.name.toLowerCase().replace(/[-_]/g, '');\n      const score = this.calculateSimilarity(search, normalized);\n      if (score > 0.3) { // Lower threshold for suggestions\n        scored.push({ entry, score });\n      }\n    }\n    \n    // Sort by score and return top 5\n    return scored\n      .sort((a, b) => b.score - a.score)\n      .slice(0, 5)\n      .map(s => ({ name: s.entry.name }));\n  }\n  \n  /**\n   * Calculate similarity between two strings\n   * Returns a score between 0 and 1\n   */\n  private calculateSimilarity(a: string, b: string): number {\n    // Exact match\n    if (a === b) return 1.0;\n    \n    // One contains the other\n    if (a.includes(b) || b.includes(a)) return 0.8;\n    \n    // Calculate word overlap\n    const wordsA = a.split(/[^a-z0-9]+/);\n    const wordsB = b.split(/[^a-z0-9]+/);\n    \n    let matches = 0;\n    for (const wordA of wordsA) {\n      if (wordA && wordsB.some(wordB => wordB === wordA)) {\n        matches++;\n      }\n    }\n    \n    if (matches > 0) {\n      const overlap = (matches * 2) / (wordsA.length + wordsB.length);\n      return Math.max(0.6, overlap); // At least 0.6 for any word match\n    }\n    \n    // Check for partial matches\n    for (const wordA of wordsA) {\n      for (const wordB of wordsB) {\n        if (wordA.length > 3 && wordB.length > 3) {\n          if (wordA.includes(wordB) || wordB.includes(wordA)) {\n            return 0.5;\n          }\n        }\n      }\n    }\n    \n    // No significant similarity\n    return 0;\n  }\n}"]}