@dollhousemcp/mcp-server 1.7.3 → 1.7.4

package/dist/handlers/PortfolioPullHandler.js

@@ -0,0 +1,340 @@
+/**
+ * PortfolioPullHandler - Handles pulling portfolio elements from GitHub
+ *
+ * This handler implements the pull functionality for sync_portfolio,
+ * enabling users to download their portfolio from GitHub to local storage.
+ * Supports multiple sync modes (additive, mirror, backup) and dry-run.
+ */
+import { PortfolioRepoManager } from '../portfolio/PortfolioRepoManager.js';
+import { GitHubPortfolioIndexer } from '../portfolio/GitHubPortfolioIndexer.js';
+import { PortfolioManager } from '../portfolio/PortfolioManager.js';
+import { PortfolioIndexManager } from '../portfolio/PortfolioIndexManager.js';
+import { ElementType } from '../portfolio/types.js';
+import { logger } from '../utils/logger.js';
+import { PortfolioSyncComparer } from '../sync/PortfolioSyncComparer.js';
+import { PortfolioDownloader } from '../sync/PortfolioDownloader.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { getPortfolioRepositoryName } from '../config/portfolioConfig.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class PortfolioPullHandler {
+    portfolioRepoManager;
+    githubIndexer;
+    portfolioManager;
+    indexManager;
+    syncComparer;
+    downloader;
+    constructor() {
+        this.portfolioRepoManager = new PortfolioRepoManager(getPortfolioRepositoryName());
+        this.githubIndexer = GitHubPortfolioIndexer.getInstance();
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.indexManager = PortfolioIndexManager.getInstance();
+        this.syncComparer = new PortfolioSyncComparer();
+        this.downloader = new PortfolioDownloader();
+    }
+    /**
+     * Execute the pull operation from GitHub to local portfolio
+     */
+    async executePull(options, personaIndicator) {
+        try {
+            logger.info('Starting portfolio pull operation', { options });
+            // Step 1: Validate sync mode
+            const syncMode = this.validateSyncMode(options.mode);
+            // Step 2: Fetch GitHub portfolio index
+            const progressMessages = [];
+            progressMessages.push('🔍 Fetching portfolio from GitHub...');
+            const githubIndex = await this.githubIndexer.getIndex(true);
+            if (!githubIndex || githubIndex.totalElements === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `${personaIndicator}⚠️ No elements found in GitHub portfolio. Nothing to pull.`
+                        }]
+                };
+            }
+            progressMessages.push(`📊 Found ${githubIndex.totalElements} elements on GitHub`);
+            // Step 3: Get local portfolio state
+            await this.indexManager.rebuildIndex();
+            const localElements = await this.getAllLocalElements();
+            progressMessages.push(`📁 Found ${this.countElements(localElements)} local elements`);
+            // Step 4: Compare and determine sync actions
+            const syncActions = this.syncComparer.compareElements(githubIndex.elements, localElements, syncMode);
+            // Step 5: Handle dry-run mode
+            if (options.dryRun) {
+                return this.formatDryRunResults(syncActions, progressMessages, personaIndicator);
+            }
+            // Step 6: Check for deletions requiring confirmation
+            if (syncActions.toDelete.length > 0 &&
+                syncMode === 'mirror' &&
+                !options.force &&
+                options.confirmDeletions !== false) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `${personaIndicator}⚠️ Pull operation would delete ${syncActions.toDelete.length} local elements.\n\n` +
+                                `Elements to delete:\n${syncActions.toDelete.map(a => `  - ${a.name}`).join('\n')}\n\n` +
+                                `To proceed, run with \`force: true\` or \`confirmDeletions: false\``
+                        }]
+                };
+            }
+            // Step 7: Execute sync actions
+            const results = await this.executeSyncActions(syncActions, githubIndex.username, githubIndex.repository, progressMessages);
+            // Step 8: Return success summary
+            return {
+                content: [{
+                        type: "text",
+                        text: `${personaIndicator}✅ **Portfolio Pull Complete**\n\n` +
+                            progressMessages.join('\n') + '\n\n' +
+                            `**Summary:**\n` +
+                            `  📥 Added: ${results.added}\n` +
+                            `  🔄 Updated: ${results.updated}\n` +
+                            `  🔗 Skipped: ${results.skipped}\n` +
+                            (results.deleted > 0 ? `  🗑️ Deleted: ${results.deleted}\n` : '') +
+                            `\nYour local portfolio is now synchronized with GitHub!`
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Portfolio pull failed', { error });
+            return {
+                content: [{
+                        type: "text",
+                        text: `${personaIndicator}❌ Failed to pull portfolio: ${error instanceof Error ? error.message : String(error)}`
+                    }]
+            };
+        }
+    }
+    /**
+     * Validate and normalize sync mode
+     * SECURITY FIX: Added Unicode normalization to prevent homograph attacks
+     */
+    validateSyncMode(mode) {
+        const validModes = ['additive', 'mirror', 'backup'];
+        // SECURITY FIX: Normalize Unicode to prevent homograph attacks
+        const normalizedMode = mode ?
+            UnicodeValidator.normalize(mode).normalizedContent :
+            'additive';
+        const syncMode = normalizedMode.toLowerCase();
+        if (!validModes.includes(syncMode)) {
+            throw new Error(`Invalid sync mode: ${mode}. Valid modes are: ${validModes.join(', ')}`);
+        }
+        return syncMode;
+    }
+    /**
+     * Get all local elements organized by type
+     */
+    async getAllLocalElements() {
+        const elements = new Map();
+        const elementTypes = Object.values(ElementType);
+        for (const type of elementTypes) {
+            const typeElements = await this.indexManager.getElementsByType(type);
+            if (typeElements.length > 0) {
+                elements.set(type, typeElements);
+            }
+        }
+        return elements;
+    }
+    /**
+     * Count total elements in a map
+     */
+    countElements(elements) {
+        let count = 0;
+        for (const typeElements of elements.values()) {
+            count += typeElements.length;
+        }
+        return count;
+    }
+    /**
+     * Format dry-run results for display
+     */
+    formatDryRunResults(syncActions, progressMessages, personaIndicator) {
+        const lines = [
+            `${personaIndicator}🔍 **Dry Run Results**`,
+            '',
+            ...progressMessages,
+            '',
+            '**Planned Actions:**'
+        ];
+        if (syncActions.toAdd.length > 0) {
+            lines.push(`\n📥 **To Add (${syncActions.toAdd.length}):**`);
+            syncActions.toAdd.forEach(action => {
+                lines.push(`  - ${action.type}/${action.name}`);
+            });
+        }
+        if (syncActions.toUpdate.length > 0) {
+            lines.push(`\n🔄 **To Update (${syncActions.toUpdate.length}):**`);
+            syncActions.toUpdate.forEach(action => {
+                lines.push(`  - ${action.type}/${action.name}`);
+            });
+        }
+        if (syncActions.toDelete.length > 0) {
+            lines.push(`\n🗑️ **To Delete (${syncActions.toDelete.length}):**`);
+            syncActions.toDelete.forEach(action => {
+                lines.push(`  - ${action.type}/${action.name}`);
+            });
+        }
+        if (syncActions.toSkip.length > 0) {
+            lines.push(`\n🔗 **To Skip (${syncActions.toSkip.length}):**`);
+            syncActions.toSkip.forEach(action => {
+                lines.push(`  - ${action.type}/${action.name} (${action.reason})`);
+            });
+        }
+        lines.push('', 'Run without `dryRun: true` to execute these changes.');
+        return {
+            content: [{
+                    type: "text",
+                    text: lines.join('\n')
+                }]
+        };
+    }
+    /**
+     * Execute the sync actions
+     */
+    async executeSyncActions(syncActions, username, repository, progressMessages) {
+        const results = {
+            added: 0,
+            updated: 0,
+            deleted: 0,
+            skipped: syncActions.toSkip.length
+        };
+        // PERFORMANCE: Process downloads in parallel batches for improved speed
+        const BATCH_SIZE = 5; // Process 5 downloads at a time to avoid rate limiting
+        // Helper function to process a batch of actions
+        const processBatch = async (actions, operation) => {
+            const results = await Promise.allSettled(actions.map(async (action) => {
+                progressMessages.push(`${operation}: ${action.type}/${action.name}`);
+                await this.downloadAndSaveElement(action, username, repository);
+                return action;
+            }));
+            return results.map((result, index) => ({
+                action: actions[index],
+                success: result.status === 'fulfilled',
+                error: result.status === 'rejected' ? result.reason : null
+            }));
+        };
+        // Process additions in batches
+        for (let i = 0; i < syncActions.toAdd.length; i += BATCH_SIZE) {
+            const batch = syncActions.toAdd.slice(i, i + BATCH_SIZE);
+            const batchResults = await processBatch(batch, '📥 Downloading');
+            for (const result of batchResults) {
+                if (result.success) {
+                    results.added++;
+                }
+                else {
+                    logger.error(`Failed to add ${result.action.type}/${result.action.name}`, { error: result.error });
+                    progressMessages.push(`❌ Failed to add: ${result.action.type}/${result.action.name}`);
+                }
+            }
+        }
+        // Process updates in batches
+        for (let i = 0; i < syncActions.toUpdate.length; i += BATCH_SIZE) {
+            const batch = syncActions.toUpdate.slice(i, i + BATCH_SIZE);
+            const batchResults = await processBatch(batch, '🔄 Updating');
+            for (const result of batchResults) {
+                if (result.success) {
+                    results.updated++;
+                }
+                else {
+                    logger.error(`Failed to update ${result.action.type}/${result.action.name}`, { error: result.error });
+                    progressMessages.push(`❌ Failed to update: ${result.action.type}/${result.action.name}`);
+                }
+            }
+        }
+        // Process deletions
+        for (const action of syncActions.toDelete) {
+            try {
+                progressMessages.push(`🗑️ Deleting: ${action.type}/${action.name}`);
+                await this.deleteLocalElement(action);
+                results.deleted++;
+            }
+            catch (error) {
+                logger.error(`Failed to delete ${action.type}/${action.name}`, { error });
+                progressMessages.push(`❌ Failed to delete: ${action.type}/${action.name}`);
+            }
+        }
+        // PERFORMANCE: Batch rebuild index after all operations complete
+        if (results.added > 0 || results.updated > 0 || results.deleted > 0) {
+            progressMessages.push('🔄 Rebuilding index...');
+            await this.indexManager.rebuildIndex();
+        }
+        return results;
+    }
+    /**
+     * Download element from GitHub and save locally
+     * SECURITY: Added audit logging for GitHub operations
+     */
+    async downloadAndSaveElement(action, username, repository) {
+        // Set up the repo manager with the correct context
+        this.portfolioRepoManager.setToken(await this.getGitHubToken());
+        // SECURITY: Log the download operation for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'PORTFOLIO_FETCH_SUCCESS',
+            severity: 'LOW',
+            source: 'PortfolioPullHandler.downloadAndSaveElement',
+            details: `Downloading element: ${action.type}/${action.name} from ${username}/${repository}`
+        });
+        // Download the element content
+        const elementData = await this.downloader.downloadFromGitHub(this.portfolioRepoManager, action.path, username, repository);
+        // Save to local portfolio
+        const elementDir = this.portfolioManager.getElementDir(action.type);
+        const fileName = path.basename(action.path);
+        const filePath = path.join(elementDir, fileName);
+        await fs.writeFile(filePath, elementData.content, 'utf-8');
+        // SECURITY: Log successful save for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'ELEMENT_CREATED',
+            severity: 'LOW',
+            source: 'PortfolioPullHandler.downloadAndSaveElement',
+            details: `Saved element to: ${action.type}/${fileName}`
+        });
+        // PERFORMANCE: Skip individual index rebuild - will batch rebuild after all operations
+    }
+    /**
+     * Delete local element
+     * SECURITY: Added audit logging for deletion operations
+     */
+    async deleteLocalElement(action) {
+        const elementDir = this.portfolioManager.getElementDir(action.type);
+        // Use the original filename from the path to preserve extension
+        const fileName = path.basename(action.path) || `${action.name}.md`;
+        const filePath = path.join(elementDir, fileName);
+        // SECURITY: Log deletion attempt for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'ELEMENT_DELETED',
+            severity: 'MEDIUM',
+            source: 'PortfolioPullHandler.deleteLocalElement',
+            details: `Attempting to delete: ${action.type}/${fileName}`
+        });
+        try {
+            await fs.unlink(filePath);
+            // PERFORMANCE: Skip individual index rebuild - will batch rebuild after all operations
+            // SECURITY: Log successful deletion
+            SecurityMonitor.logSecurityEvent({
+                type: 'ELEMENT_DELETED',
+                severity: 'MEDIUM',
+                source: 'PortfolioPullHandler.deleteLocalElement',
+                details: `Successfully deleted: ${action.type}/${fileName}`
+            });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            // File already doesn't exist, that's fine
+        }
+    }
+    /**
+     * Get GitHub token from auth manager
+     */
+    async getGitHubToken() {
+        // This should use the same token management as the rest of the system
+        const { TokenManager } = await import('../security/tokenManager.js');
+        const token = await TokenManager.getGitHubTokenAsync();
+        if (!token) {
+            throw new Error('GitHub authentication required. Please run setup_github_auth first.');
+        }
+        return token;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioPullHandler.js","sourceRoot":"","sources":["../../src/handlers/PortfolioPullHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PortfolioPullHandler - Handles pulling portfolio elements from GitHub\n * \n * This handler implements the pull functionality for sync_portfolio,\n * enabling users to download their portfolio from GitHub to local storage.\n * Supports multiple sync modes (additive, mirror, backup) and dry-run.\n */\n\nimport { PortfolioRepoManager } from '../portfolio/PortfolioRepoManager.js';\nimport { GitHubPortfolioIndexer } from '../portfolio/GitHubPortfolioIndexer.js';\nimport { PortfolioManager } from '../portfolio/PortfolioManager.js';\nimport { PortfolioIndexManager } from '../portfolio/PortfolioIndexManager.js';\nimport { ElementType } from '../portfolio/types.js';\nimport { logger } from '../utils/logger.js';\nimport { PortfolioSyncComparer, SyncMode, SyncAction } from '../sync/PortfolioSyncComparer.js';\nimport { PortfolioDownloader } from '../sync/PortfolioDownloader.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { getPortfolioRepositoryName } from '../config/portfolioConfig.js';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nexport interface PullOptions {\n  direction: string;\n  mode?: string;\n  force?: boolean;\n  dryRun?: boolean;\n  confirmDeletions?: boolean;\n}\n\nexport interface PullResult {\n  content: Array<{\n    type: string;\n    text: string;\n  }>;\n}\n\nexport class PortfolioPullHandler {\n  private portfolioRepoManager: PortfolioRepoManager;\n  private githubIndexer: GitHubPortfolioIndexer;\n  private portfolioManager: PortfolioManager;\n  private indexManager: PortfolioIndexManager;\n  private syncComparer: PortfolioSyncComparer;\n  private downloader: PortfolioDownloader;\n\n  constructor() {\n    this.portfolioRepoManager = new PortfolioRepoManager(getPortfolioRepositoryName());\n    this.githubIndexer = GitHubPortfolioIndexer.getInstance();\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.indexManager = PortfolioIndexManager.getInstance();\n    this.syncComparer = new PortfolioSyncComparer();\n    this.downloader = new PortfolioDownloader();\n  }\n\n  /**\n   * Execute the pull operation from GitHub to local portfolio\n   */\n  async executePull(options: PullOptions, personaIndicator: string): Promise<PullResult> {\n    try {\n      logger.info('Starting portfolio pull operation', { options });\n      \n      // Step 1: Validate sync mode\n      const syncMode = this.validateSyncMode(options.mode);\n      \n      // Step 2: Fetch GitHub portfolio index\n      const progressMessages: string[] = [];\n      progressMessages.push('🔍 Fetching portfolio from GitHub...');\n      \n      const githubIndex = await this.githubIndexer.getIndex(true);\n      \n      if (!githubIndex || githubIndex.totalElements === 0) {\n        return {\n          content: [{\n            type: \"text\",\n            text: `${personaIndicator}⚠️ No elements found in GitHub portfolio. Nothing to pull.`\n          }]\n        };\n      }\n      \n      progressMessages.push(`📊 Found ${githubIndex.totalElements} elements on GitHub`);\n      \n      // Step 3: Get local portfolio state\n      await this.indexManager.rebuildIndex();\n      const localElements = await this.getAllLocalElements();\n      progressMessages.push(`📁 Found ${this.countElements(localElements)} local elements`);\n      \n      // Step 4: Compare and determine sync actions\n      const syncActions = this.syncComparer.compareElements(\n        githubIndex.elements,\n        localElements,\n        syncMode\n      );\n      \n      // Step 5: Handle dry-run mode\n      if (options.dryRun) {\n        return this.formatDryRunResults(syncActions, progressMessages, personaIndicator);\n      }\n      \n      // Step 6: Check for deletions requiring confirmation\n      if (syncActions.toDelete.length > 0 && \n          syncMode === 'mirror' && \n          !options.force && \n          options.confirmDeletions !== false) {\n        return {\n          content: [{\n            type: \"text\",\n            text: `${personaIndicator}⚠️ Pull operation would delete ${syncActions.toDelete.length} local elements.\\n\\n` +\n                  `Elements to delete:\\n${syncActions.toDelete.map(a => `  - ${a.name}`).join('\\n')}\\n\\n` +\n                  `To proceed, run with \\`force: true\\` or \\`confirmDeletions: false\\``\n          }]\n        };\n      }\n      \n      // Step 7: Execute sync actions\n      const results = await this.executeSyncActions(\n        syncActions, \n        githubIndex.username, \n        githubIndex.repository,\n        progressMessages\n      );\n      \n      // Step 8: Return success summary\n      return {\n        content: [{\n          type: \"text\",\n          text: `${personaIndicator}✅ **Portfolio Pull Complete**\\n\\n` +\n                progressMessages.join('\\n') + '\\n\\n' +\n                `**Summary:**\\n` +\n                `  📥 Added: ${results.added}\\n` +\n                `  🔄 Updated: ${results.updated}\\n` +\n                `  🔗 Skipped: ${results.skipped}\\n` +\n                (results.deleted > 0 ? `  🗑️ Deleted: ${results.deleted}\\n` : '') +\n                `\\nYour local portfolio is now synchronized with GitHub!`\n        }]\n      };\n      \n    } catch (error) {\n      logger.error('Portfolio pull failed', { error });\n      return {\n        content: [{\n          type: \"text\",\n          text: `${personaIndicator}❌ Failed to pull portfolio: ${error instanceof Error ? error.message : String(error)}`\n        }]\n      };\n    }\n  }\n\n  /**\n   * Validate and normalize sync mode\n   * SECURITY FIX: Added Unicode normalization to prevent homograph attacks\n   */\n  private validateSyncMode(mode?: string): SyncMode {\n    const validModes: SyncMode[] = ['additive', 'mirror', 'backup'];\n    \n    // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n    const normalizedMode = mode ? \n      UnicodeValidator.normalize(mode).normalizedContent : \n      'additive';\n    \n    const syncMode = normalizedMode.toLowerCase() as SyncMode;\n    \n    if (!validModes.includes(syncMode)) {\n      throw new Error(`Invalid sync mode: ${mode}. Valid modes are: ${validModes.join(', ')}`);\n    }\n    \n    return syncMode;\n  }\n\n  /**\n   * Get all local elements organized by type\n   */\n  private async getAllLocalElements(): Promise<Map<ElementType, any[]>> {\n    const elements = new Map<ElementType, any[]>();\n    const elementTypes = Object.values(ElementType);\n    \n    for (const type of elementTypes) {\n      const typeElements = await this.indexManager.getElementsByType(type);\n      if (typeElements.length > 0) {\n        elements.set(type, typeElements);\n      }\n    }\n    \n    return elements;\n  }\n\n  /**\n   * Count total elements in a map\n   */\n  private countElements(elements: Map<ElementType, any[]>): number {\n    let count = 0;\n    for (const typeElements of elements.values()) {\n      count += typeElements.length;\n    }\n    return count;\n  }\n\n  /**\n   * Format dry-run results for display\n   */\n  private formatDryRunResults(\n    syncActions: { toAdd: SyncAction[], toUpdate: SyncAction[], toDelete: SyncAction[], toSkip: SyncAction[] },\n    progressMessages: string[],\n    personaIndicator: string\n  ): PullResult {\n    const lines = [\n      `${personaIndicator}🔍 **Dry Run Results**`,\n      '',\n      ...progressMessages,\n      '',\n      '**Planned Actions:**'\n    ];\n    \n    if (syncActions.toAdd.length > 0) {\n      lines.push(`\\n📥 **To Add (${syncActions.toAdd.length}):**`);\n      syncActions.toAdd.forEach(action => {\n        lines.push(`  - ${action.type}/${action.name}`);\n      });\n    }\n    \n    if (syncActions.toUpdate.length > 0) {\n      lines.push(`\\n🔄 **To Update (${syncActions.toUpdate.length}):**`);\n      syncActions.toUpdate.forEach(action => {\n        lines.push(`  - ${action.type}/${action.name}`);\n      });\n    }\n    \n    if (syncActions.toDelete.length > 0) {\n      lines.push(`\\n🗑️ **To Delete (${syncActions.toDelete.length}):**`);\n      syncActions.toDelete.forEach(action => {\n        lines.push(`  - ${action.type}/${action.name}`);\n      });\n    }\n    \n    if (syncActions.toSkip.length > 0) {\n      lines.push(`\\n🔗 **To Skip (${syncActions.toSkip.length}):**`);\n      syncActions.toSkip.forEach(action => {\n        lines.push(`  - ${action.type}/${action.name} (${action.reason})`);\n      });\n    }\n    \n    lines.push('', 'Run without `dryRun: true` to execute these changes.');\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: lines.join('\\n')\n      }]\n    };\n  }\n\n  /**\n   * Execute the sync actions\n   */\n  private async executeSyncActions(\n    syncActions: { toAdd: SyncAction[], toUpdate: SyncAction[], toDelete: SyncAction[], toSkip: SyncAction[] },\n    username: string,\n    repository: string,\n    progressMessages: string[]\n  ): Promise<{ added: number, updated: number, deleted: number, skipped: number }> {\n    const results = {\n      added: 0,\n      updated: 0,\n      deleted: 0,\n      skipped: syncActions.toSkip.length\n    };\n    \n    // PERFORMANCE: Process downloads in parallel batches for improved speed\n    const BATCH_SIZE = 5; // Process 5 downloads at a time to avoid rate limiting\n    \n    // Helper function to process a batch of actions\n    const processBatch = async (actions: SyncAction[], operation: string) => {\n      const results = await Promise.allSettled(\n        actions.map(async (action) => {\n          progressMessages.push(`${operation}: ${action.type}/${action.name}`);\n          await this.downloadAndSaveElement(action, username, repository);\n          return action;\n        })\n      );\n      \n      return results.map((result, index) => ({\n        action: actions[index],\n        success: result.status === 'fulfilled',\n        error: result.status === 'rejected' ? result.reason : null\n      }));\n    };\n    \n    // Process additions in batches\n    for (let i = 0; i < syncActions.toAdd.length; i += BATCH_SIZE) {\n      const batch = syncActions.toAdd.slice(i, i + BATCH_SIZE);\n      const batchResults = await processBatch(batch, '📥 Downloading');\n      \n      for (const result of batchResults) {\n        if (result.success) {\n          results.added++;\n        } else {\n          logger.error(`Failed to add ${result.action.type}/${result.action.name}`, { error: result.error });\n          progressMessages.push(`❌ Failed to add: ${result.action.type}/${result.action.name}`);\n        }\n      }\n    }\n    \n    // Process updates in batches\n    for (let i = 0; i < syncActions.toUpdate.length; i += BATCH_SIZE) {\n      const batch = syncActions.toUpdate.slice(i, i + BATCH_SIZE);\n      const batchResults = await processBatch(batch, '🔄 Updating');\n      \n      for (const result of batchResults) {\n        if (result.success) {\n          results.updated++;\n        } else {\n          logger.error(`Failed to update ${result.action.type}/${result.action.name}`, { error: result.error });\n          progressMessages.push(`❌ Failed to update: ${result.action.type}/${result.action.name}`);\n        }\n      }\n    }\n    \n    // Process deletions\n    for (const action of syncActions.toDelete) {\n      try {\n        progressMessages.push(`🗑️ Deleting: ${action.type}/${action.name}`);\n        await this.deleteLocalElement(action);\n        results.deleted++;\n      } catch (error) {\n        logger.error(`Failed to delete ${action.type}/${action.name}`, { error });\n        progressMessages.push(`❌ Failed to delete: ${action.type}/${action.name}`);\n      }\n    }\n    \n    // PERFORMANCE: Batch rebuild index after all operations complete\n    if (results.added > 0 || results.updated > 0 || results.deleted > 0) {\n      progressMessages.push('🔄 Rebuilding index...');\n      await this.indexManager.rebuildIndex();\n    }\n    \n    return results;\n  }\n\n  /**\n   * Download element from GitHub and save locally\n   * SECURITY: Added audit logging for GitHub operations\n   */\n  private async downloadAndSaveElement(\n    action: SyncAction,\n    username: string,\n    repository: string\n  ): Promise<void> {\n    // Set up the repo manager with the correct context\n    this.portfolioRepoManager.setToken(await this.getGitHubToken());\n    \n    // SECURITY: Log the download operation for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_FETCH_SUCCESS',\n      severity: 'LOW',\n      source: 'PortfolioPullHandler.downloadAndSaveElement',\n      details: `Downloading element: ${action.type}/${action.name} from ${username}/${repository}`\n    });\n    \n    // Download the element content\n    const elementData = await this.downloader.downloadFromGitHub(\n      this.portfolioRepoManager,\n      action.path,\n      username,\n      repository\n    );\n    \n    // Save to local portfolio\n    const elementDir = this.portfolioManager.getElementDir(action.type);\n    const fileName = path.basename(action.path);\n    const filePath = path.join(elementDir, fileName);\n    \n    await fs.writeFile(filePath, elementData.content, 'utf-8');\n    \n    // SECURITY: Log successful save for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'ELEMENT_CREATED',\n      severity: 'LOW',\n      source: 'PortfolioPullHandler.downloadAndSaveElement',\n      details: `Saved element to: ${action.type}/${fileName}`\n    });\n    \n    // PERFORMANCE: Skip individual index rebuild - will batch rebuild after all operations\n  }\n\n  /**\n   * Delete local element\n   * SECURITY: Added audit logging for deletion operations\n   */\n  private async deleteLocalElement(action: SyncAction): Promise<void> {\n    const elementDir = this.portfolioManager.getElementDir(action.type);\n    // Use the original filename from the path to preserve extension\n    const fileName = path.basename(action.path) || `${action.name}.md`;\n    const filePath = path.join(elementDir, fileName);\n    \n    // SECURITY: Log deletion attempt for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'ELEMENT_DELETED',\n      severity: 'MEDIUM',\n      source: 'PortfolioPullHandler.deleteLocalElement',\n      details: `Attempting to delete: ${action.type}/${fileName}`\n    });\n    \n    try {\n      await fs.unlink(filePath);\n      // PERFORMANCE: Skip individual index rebuild - will batch rebuild after all operations\n      \n      // SECURITY: Log successful deletion\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_DELETED',\n        severity: 'MEDIUM',\n        source: 'PortfolioPullHandler.deleteLocalElement',\n        details: `Successfully deleted: ${action.type}/${fileName}`\n      });\n    } catch (error: any) {\n      if (error.code !== 'ENOENT') {\n        throw error;\n      }\n      // File already doesn't exist, that's fine\n    }\n  }\n\n  /**\n   * Get GitHub token from auth manager\n   */\n  private async getGitHubToken(): Promise<string> {\n    // This should use the same token management as the rest of the system\n    const { TokenManager } = await import('../security/tokenManager.js');\n    const token = await TokenManager.getGitHubTokenAsync();\n    if (!token) {\n      throw new Error('GitHub authentication required. Please run setup_github_auth first.');\n    }\n    return token;\n  }\n}"]}

package/dist/scripts/scripts/run-config-wizard.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Standalone script to run the configuration wizard
+ * Can be used for testing or manual configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConfigWizard = main;
+const ConfigManager_js_1 = require("../src/config/ConfigManager.js");
+const ConfigWizard_js_1 = require("../src/config/ConfigWizard.js");
+const chalk_1 = require("chalk");
+async function main() {
+    try {
+        // Initialize config manager
+        const configManager = ConfigManager_js_1.ConfigManager.getInstance();
+        await configManager.initialize();
+        // Create and run wizard
+        const wizard = new ConfigWizard_js_1.ConfigWizard(configManager);
+        // Check if we should force run (for testing)
+        const forceRun = process.argv.includes('--force');
+        if (forceRun || await wizard.shouldRunWizard()) {
+            const choice = await wizard.promptInitial();
+            if (choice === 'yes') {
+                await wizard.runWizard();
+            }
+            else if (choice === 'never') {
+                await wizard.markDismissed();
+                console.log(chalk_1.default.gray('\nWizard dismissed. You can run it manually anytime.\n'));
+            }
+            else {
+                console.log(chalk_1.default.gray('\nSkipped for now. The wizard will ask again next time.\n'));
+            }
+        }
+        else {
+            const config = configManager.getConfig();
+            if (config.wizard?.completed) {
+                console.log(chalk_1.default.green('\n✅ Configuration wizard already completed.'));
+                console.log(chalk_1.default.gray('Use --force to run it again.\n'));
+            }
+            else if (config.wizard?.dismissed) {
+                console.log(chalk_1.default.yellow('\n⚠️  Configuration wizard was previously dismissed.'));
+                console.log(chalk_1.default.gray('Use --force to run it anyway.\n'));
+            }
+        }
+        // Clean up
+        wizard.close();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error running configuration wizard:'), error);
+        process.exit(1);
+    }
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}