@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/portfolio/GitHubPortfolioIndexer.js

@@ -0,0 +1,475 @@
+/**
+ * GitHub Portfolio Indexer - Fetches and indexes user's GitHub portfolio for fast searching
+ *
+ * Features:
+ * - Singleton pattern for efficient resource usage
+ * - Smart caching with TTL and invalidation after user actions
+ * - GraphQL/REST API integration for efficient fetching
+ * - Rate limiting and authentication handling
+ * - Fallback strategy for resilient operation
+ * - Performance optimized for 1000+ portfolio elements
+ */
+import { GitHubClient } from '../collection/GitHubClient.js';
+import { PortfolioRepoManager } from './PortfolioRepoManager.js';
+import { ElementType } from './types.js';
+import { logger } from '../utils/logger.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';
+import { APICache } from '../cache/APICache.js';
+export class GitHubPortfolioIndexer {
+    static instance = null;
+    static instanceLock = false;
+    cache = null;
+    lastFetch = null;
+    ttl = 15 * 60 * 1000; // 15 minutes
+    recentUserAction = false;
+    actionTimestamp = null;
+    actionGracePeriod = 2 * 60 * 1000; // 2 minutes after action
+    githubClient;
+    portfolioRepoManager;
+    apiCache;
+    rateLimitTracker;
+    constructor() {
+        this.apiCache = new APICache(); // Uses default settings
+        this.rateLimitTracker = new Map();
+        this.githubClient = new GitHubClient(this.apiCache, this.rateLimitTracker);
+        this.portfolioRepoManager = new PortfolioRepoManager();
+        logger.debug('GitHubPortfolioIndexer created');
+    }
+    /**
+     * Singleton pattern with thread safety
+     */
+    static getInstance() {
+        if (!this.instance) {
+            if (this.instanceLock) {
+                throw new Error('GitHubPortfolioIndexer instance is being created by another thread');
+            }
+            try {
+                this.instanceLock = true;
+                this.instance = new GitHubPortfolioIndexer();
+            }
+            finally {
+                this.instanceLock = false;
+            }
+        }
+        return this.instance;
+    }
+    /**
+     * Main method to get GitHub portfolio index
+     */
+    async getIndex(force = false) {
+        try {
+            // Check if we need fresh data
+            if (force || this.shouldFetchFresh()) {
+                return await this.fetchFresh();
+            }
+            // Return cached data if available and valid
+            if (this.cache && this.isCacheValid()) {
+                logger.debug('Returning cached GitHub portfolio index', {
+                    username: this.cache.username,
+                    totalElements: this.cache.totalElements,
+                    age: this.lastFetch ? Date.now() - this.lastFetch.getTime() : 'unknown'
+                });
+                return this.cache;
+            }
+            // Try to fetch fresh, fall back to stale cache on failure
+            try {
+                return await this.fetchFresh();
+            }
+            catch (error) {
+                logger.warn('Failed to fetch fresh GitHub portfolio index, checking for stale cache', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                // Return stale cache if available
+                if (this.cache) {
+                    logger.info('Returning stale GitHub portfolio cache as fallback', {
+                        username: this.cache.username,
+                        age: this.lastFetch ? Date.now() - this.lastFetch.getTime() : 'unknown'
+                    });
+                    return this.cache;
+                }
+                // Return empty index as last resort
+                return this.createEmptyIndex();
+            }
+        }
+        catch (error) {
+            ErrorHandler.logError('GitHubPortfolioIndexer.getIndex', error);
+            // Return stale cache or empty index
+            if (this.cache) {
+                return this.cache;
+            }
+            return this.createEmptyIndex();
+        }
+    }
+    /**
+     * Invalidate cache after user actions
+     */
+    invalidateAfterAction(action) {
+        logger.info('Invalidating GitHub portfolio cache after user action', { action });
+        this.recentUserAction = true;
+        this.actionTimestamp = new Date();
+        // Log security event for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'PORTFOLIO_CACHE_INVALIDATION',
+            severity: 'LOW',
+            source: 'GitHubPortfolioIndexer.invalidateAfterAction',
+            details: `Cache invalidated after user action: ${action}`,
+            metadata: { action }
+        });
+    }
+    /**
+     * Clear all cached data
+     */
+    clearCache() {
+        this.cache = null;
+        this.lastFetch = null;
+        this.recentUserAction = false;
+        this.actionTimestamp = null;
+        this.apiCache.clear();
+        logger.info('GitHub portfolio cache cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            hasCachedData: this.cache !== null,
+            lastFetch: this.lastFetch,
+            isStale: !this.isCacheValid(),
+            recentUserAction: this.recentUserAction,
+            totalElements: this.cache?.totalElements || 0
+        };
+    }
+    /**
+     * Fetch fresh data from GitHub
+     */
+    async fetchFresh() {
+        const startTime = Date.now();
+        logger.info('Fetching fresh GitHub portfolio index...');
+        try {
+            // Get GitHub username from token
+            const username = await this.getGitHubUsername();
+            const repository = 'dollhouse-portfolio';
+            // Check if portfolio repository exists
+            const repoExists = await this.portfolioRepoManager.checkPortfolioExists(username);
+            if (!repoExists) {
+                logger.info('GitHub portfolio repository does not exist', { username });
+                return this.createEmptyIndex(username, repository);
+            }
+            // Fetch repository content using GitHub API
+            const index = await this.fetchRepositoryContent(username, repository);
+            // Update cache
+            this.cache = index;
+            this.lastFetch = new Date();
+            this.recentUserAction = false;
+            this.actionTimestamp = null;
+            const duration = Date.now() - startTime;
+            logger.info('GitHub portfolio index fetched successfully', {
+                username,
+                totalElements: index.totalElements,
+                duration: `${duration}ms`,
+                rateLimitRemaining: index.rateLimitInfo?.remaining
+            });
+            // Log security event
+            SecurityMonitor.logSecurityEvent({
+                type: 'PORTFOLIO_FETCH_SUCCESS',
+                severity: 'LOW',
+                source: 'GitHubPortfolioIndexer.fetchFresh',
+                details: `Fetched GitHub portfolio with ${index.totalElements} elements in ${duration}ms`,
+                metadata: { username, duration, totalElements: index.totalElements }
+            });
+            return index;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            ErrorHandler.logError('GitHubPortfolioIndexer.fetchFresh', error, { duration });
+            throw ErrorHandler.wrapError(error, 'Failed to fetch GitHub portfolio index', ErrorCategory.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Fetch repository content from GitHub API
+     */
+    async fetchRepositoryContent(username, repository) {
+        // Try GraphQL first for better performance, fallback to REST
+        try {
+            return await this.fetchWithGraphQL(username, repository);
+        }
+        catch (graphqlError) {
+            logger.debug('GraphQL fetch failed, falling back to REST API', {
+                error: graphqlError instanceof Error ? graphqlError.message : String(graphqlError)
+            });
+            return await this.fetchWithREST(username, repository);
+        }
+    }
+    /**
+     * Fetch using GraphQL for better performance
+     */
+    async fetchWithGraphQL(username, repository) {
+        const query = `
+      query GetPortfolioContent($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+          defaultBranchRef {
+            target {
+              ... on Commit {
+                oid
+                history(first: 1) {
+                  nodes {
+                    committedDate
+                  }
+                }
+              }
+            }
+          }
+          object(expression: "HEAD:") {
+            ... on Tree {
+              entries {
+                name
+                type
+                object {
+                  ... on Tree {
+                    entries {
+                      name
+                      type
+                      oid
+                      object {
+                        ... on Blob {
+                          byteSize
+                          text
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        rateLimit {
+          remaining
+          resetAt
+        }
+      }
+    `;
+        const variables = { owner: username, name: repository };
+        const response = await this.githubClient.fetchFromGitHub('https://api.github.com/graphql', true);
+        // Note: This is a simplified GraphQL implementation
+        // In a real implementation, you would send POST request with query and variables
+        throw new Error('GraphQL implementation not yet complete');
+    }
+    /**
+     * Fetch using REST API with pagination
+     */
+    async fetchWithREST(username, repository) {
+        const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;
+        // Get repository info and latest commit
+        const repoInfo = await this.githubClient.fetchFromGitHub(`https://api.github.com/repos/${normalizedUsername}/${repository}`);
+        const latestCommit = await this.githubClient.fetchFromGitHub(`https://api.github.com/repos/${normalizedUsername}/${repository}/commits/HEAD`);
+        // Initialize index
+        const index = {
+            username: normalizedUsername,
+            repository,
+            lastUpdated: new Date(latestCommit.commit.committer.date),
+            elements: new Map(),
+            totalElements: 0,
+            sha: latestCommit.sha
+        };
+        // Initialize element type maps
+        for (const elementType of Object.values(ElementType)) {
+            index.elements.set(elementType, []);
+        }
+        // Fetch content for each element type
+        for (const elementType of Object.values(ElementType)) {
+            try {
+                const entries = await this.fetchElementTypeContent(normalizedUsername, repository, elementType);
+                index.elements.set(elementType, entries);
+                index.totalElements += entries.length;
+            }
+            catch (error) {
+                logger.warn(`Failed to fetch ${elementType} from GitHub portfolio`, {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                // Continue with other element types
+            }
+        }
+        return index;
+    }
+    /**
+     * Fetch content for a specific element type
+     */
+    async fetchElementTypeContent(username, repository, elementType) {
+        try {
+            // Get directory listing
+            const contents = await this.githubClient.fetchFromGitHub(`https://api.github.com/repos/${username}/${repository}/contents/${elementType}`);
+            if (!Array.isArray(contents)) {
+                return [];
+            }
+            const entries = [];
+            const maxConcurrent = 5; // Limit concurrent requests
+            // Process files in batches to avoid rate limiting
+            for (let i = 0; i < contents.length; i += maxConcurrent) {
+                const batch = contents.slice(i, i + maxConcurrent);
+                const batchPromises = batch
+                    .filter(item => item.type === 'file' && item.name.endsWith('.md'))
+                    .map(item => this.createGitHubIndexEntry(username, repository, elementType, item));
+                const batchResults = await Promise.allSettled(batchPromises);
+                for (const result of batchResults) {
+                    if (result.status === 'fulfilled' && result.value) {
+                        entries.push(result.value);
+                    }
+                }
+                // Add delay between batches to respect rate limits
+                if (i + maxConcurrent < contents.length) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            return entries;
+        }
+        catch (error) {
+            // Directory might not exist
+            if (error instanceof Error && error.message.includes('404')) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create GitHub index entry from API response
+     */
+    async createGitHubIndexEntry(username, repository, elementType, fileInfo) {
+        try {
+            // Parse metadata from filename or fetch content if needed
+            const name = fileInfo.name.replace('.md', '').replace(/-/g, ' ');
+            const entry = {
+                path: fileInfo.path,
+                name,
+                elementType,
+                sha: fileInfo.sha,
+                htmlUrl: fileInfo.html_url,
+                downloadUrl: fileInfo.download_url,
+                lastModified: new Date(), // GitHub API doesn't provide file modification time directly
+                size: fileInfo.size || 0
+            };
+            // Optionally fetch content to extract metadata
+            // This is expensive, so only do it for small files or when specifically needed
+            if (fileInfo.size && fileInfo.size < 10000) { // Only for files < 10KB
+                try {
+                    const content = await this.githubClient.fetchFromGitHub(fileInfo.download_url);
+                    const metadata = this.parseMetadataFromContent(content);
+                    if (metadata.name)
+                        entry.name = metadata.name;
+                    if (metadata.description)
+                        entry.description = metadata.description;
+                    if (metadata.version)
+                        entry.version = metadata.version;
+                    if (metadata.author)
+                        entry.author = metadata.author;
+                }
+                catch (metadataError) {
+                    // Non-critical error, continue without metadata
+                    logger.debug('Failed to fetch metadata for file', {
+                        path: fileInfo.path,
+                        error: metadataError instanceof Error ? metadataError.message : String(metadataError)
+                    });
+                }
+            }
+            return entry;
+        }
+        catch (error) {
+            logger.debug('Failed to create GitHub index entry', {
+                path: fileInfo.path,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return null;
+        }
+    }
+    /**
+     * Parse metadata from file content (frontmatter)
+     */
+    parseMetadataFromContent(content) {
+        const metadata = {};
+        // Simple frontmatter parsing (could use a proper YAML parser)
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+            const frontmatter = frontmatterMatch[1];
+            const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+            if (nameMatch)
+                metadata.name = nameMatch[1].trim();
+            const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+            if (descMatch)
+                metadata.description = descMatch[1].trim();
+            const versionMatch = frontmatter.match(/^version:\s*(.+)$/m);
+            if (versionMatch)
+                metadata.version = versionMatch[1].trim();
+            const authorMatch = frontmatter.match(/^author:\s*(.+)$/m);
+            if (authorMatch)
+                metadata.author = authorMatch[1].trim();
+        }
+        return metadata;
+    }
+    /**
+     * Get GitHub username from authenticated token
+     */
+    async getGitHubUsername() {
+        try {
+            const userInfo = await this.githubClient.fetchFromGitHub('https://api.github.com/user', true);
+            return userInfo.login;
+        }
+        catch (error) {
+            throw new Error('Failed to get GitHub username. Please ensure you are authenticated with GitHub.');
+        }
+    }
+    /**
+     * Check if cache is valid
+     */
+    isCacheValid() {
+        if (!this.cache || !this.lastFetch) {
+            return false;
+        }
+        const age = Date.now() - this.lastFetch.getTime();
+        return age < this.ttl;
+    }
+    /**
+     * Determine if we should fetch fresh data
+     */
+    shouldFetchFresh() {
+        // Always fetch if no cache
+        if (!this.cache || !this.lastFetch) {
+            return true;
+        }
+        // Check for recent user actions
+        if (this.recentUserAction && this.actionTimestamp) {
+            const actionAge = Date.now() - this.actionTimestamp.getTime();
+            if (actionAge < this.actionGracePeriod) {
+                logger.debug('Fetching fresh due to recent user action', { actionAge });
+                return true;
+            }
+            else {
+                // Grace period expired, clear action flag
+                this.recentUserAction = false;
+                this.actionTimestamp = null;
+            }
+        }
+        // Check TTL
+        return !this.isCacheValid();
+    }
+    /**
+     * Create empty index when no portfolio exists
+     */
+    createEmptyIndex(username, repository) {
+        const index = {
+            username: username || 'unknown',
+            repository: repository || 'dollhouse-portfolio',
+            lastUpdated: new Date(),
+            elements: new Map(),
+            totalElements: 0,
+            sha: ''
+        };
+        // Initialize empty element type maps
+        for (const elementType of Object.values(ElementType)) {
+            index.elements.set(elementType, []);
+        }
+        return index;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubPortfolioIndexer.js","sourceRoot":"","sources":["../../src/portfolio/GitHubPortfolioIndexer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GitHub Portfolio Indexer - Fetches and indexes user's GitHub portfolio for fast searching\n * \n * Features:\n * - Singleton pattern for efficient resource usage\n * - Smart caching with TTL and invalidation after user actions\n * - GraphQL/REST API integration for efficient fetching\n * - Rate limiting and authentication handling\n * - Fallback strategy for resilient operation\n * - Performance optimized for 1000+ portfolio elements\n */\n\nimport { GitHubClient } from '../collection/GitHubClient.js';\nimport { PortfolioRepoManager } from './PortfolioRepoManager.js';\nimport { TokenManager } from '../security/tokenManager.js';\nimport { ElementType } from './types.js';\nimport { logger } from '../utils/logger.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\nimport { APICache } from '../cache/APICache.js';\n\nexport interface GitHubIndexEntry {\n  path: string;\n  name: string;\n  description?: string;\n  version?: string;\n  author?: string;\n  elementType: ElementType;\n  sha: string; // File SHA for change detection\n  htmlUrl: string; // Link to GitHub\n  downloadUrl: string;\n  lastModified: Date;\n  size: number;\n}\n\nexport interface GitHubPortfolioIndex {\n  username: string;\n  repository: string;\n  lastUpdated: Date;\n  elements: Map<ElementType, GitHubIndexEntry[]>;\n  totalElements: number;\n  sha: string; // Latest commit SHA\n  rateLimitInfo?: {\n    remaining: number;\n    resetTime: Date;\n  };\n}\n\nexport interface GitHubFetchOptions {\n  force?: boolean;\n  maxElements?: number;\n  elementTypes?: ElementType[];\n  useGraphQL?: boolean;\n}\n\nexport class GitHubPortfolioIndexer {\n  private static instance: GitHubPortfolioIndexer | null = null;\n  private static instanceLock = false;\n  \n  private cache: GitHubPortfolioIndex | null = null;\n  private lastFetch: Date | null = null;\n  private readonly ttl = 15 * 60 * 1000; // 15 minutes\n  private recentUserAction = false;\n  private actionTimestamp: Date | null = null;\n  private readonly actionGracePeriod = 2 * 60 * 1000; // 2 minutes after action\n  \n  private githubClient: GitHubClient;\n  private portfolioRepoManager: PortfolioRepoManager;\n  private apiCache: APICache;\n  private rateLimitTracker: Map<string, number[]>;\n  \n  private constructor() {\n    this.apiCache = new APICache(); // Uses default settings\n    this.rateLimitTracker = new Map();\n    this.githubClient = new GitHubClient(this.apiCache, this.rateLimitTracker);\n    this.portfolioRepoManager = new PortfolioRepoManager();\n    \n    logger.debug('GitHubPortfolioIndexer created');\n  }\n\n  /**\n   * Singleton pattern with thread safety\n   */\n  public static getInstance(): GitHubPortfolioIndexer {\n    if (!this.instance) {\n      if (this.instanceLock) {\n        throw new Error('GitHubPortfolioIndexer instance is being created by another thread');\n      }\n      \n      try {\n        this.instanceLock = true;\n        this.instance = new GitHubPortfolioIndexer();\n      } finally {\n        this.instanceLock = false;\n      }\n    }\n    return this.instance;\n  }\n\n  /**\n   * Main method to get GitHub portfolio index\n   */\n  public async getIndex(force = false): Promise<GitHubPortfolioIndex> {\n    try {\n      // Check if we need fresh data\n      if (force || this.shouldFetchFresh()) {\n        return await this.fetchFresh();\n      }\n      \n      // Return cached data if available and valid\n      if (this.cache && this.isCacheValid()) {\n        logger.debug('Returning cached GitHub portfolio index', {\n          username: this.cache.username,\n          totalElements: this.cache.totalElements,\n          age: this.lastFetch ? Date.now() - this.lastFetch.getTime() : 'unknown'\n        });\n        return this.cache;\n      }\n      \n      // Try to fetch fresh, fall back to stale cache on failure\n      try {\n        return await this.fetchFresh();\n      } catch (error) {\n        logger.warn('Failed to fetch fresh GitHub portfolio index, checking for stale cache', {\n          error: error instanceof Error ? error.message : String(error)\n        });\n        \n        // Return stale cache if available\n        if (this.cache) {\n          logger.info('Returning stale GitHub portfolio cache as fallback', {\n            username: this.cache.username,\n            age: this.lastFetch ? Date.now() - this.lastFetch.getTime() : 'unknown'\n          });\n          return this.cache;\n        }\n        \n        // Return empty index as last resort\n        return this.createEmptyIndex();\n      }\n      \n    } catch (error) {\n      ErrorHandler.logError('GitHubPortfolioIndexer.getIndex', error);\n      \n      // Return stale cache or empty index\n      if (this.cache) {\n        return this.cache;\n      }\n      \n      return this.createEmptyIndex();\n    }\n  }\n\n  /**\n   * Invalidate cache after user actions\n   */\n  public invalidateAfterAction(action: string): void {\n    logger.info('Invalidating GitHub portfolio cache after user action', { action });\n    \n    this.recentUserAction = true;\n    this.actionTimestamp = new Date();\n    \n    // Log security event for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_CACHE_INVALIDATION',\n      severity: 'LOW',\n      source: 'GitHubPortfolioIndexer.invalidateAfterAction',\n      details: `Cache invalidated after user action: ${action}`,\n      metadata: { action }\n    });\n  }\n\n  /**\n   * Clear all cached data\n   */\n  public clearCache(): void {\n    this.cache = null;\n    this.lastFetch = null;\n    this.recentUserAction = false;\n    this.actionTimestamp = null;\n    this.apiCache.clear();\n    \n    logger.info('GitHub portfolio cache cleared');\n  }\n\n  /**\n   * Get cache statistics\n   */\n  public getCacheStats(): {\n    hasCachedData: boolean;\n    lastFetch: Date | null;\n    isStale: boolean;\n    recentUserAction: boolean;\n    totalElements: number;\n  } {\n    return {\n      hasCachedData: this.cache !== null,\n      lastFetch: this.lastFetch,\n      isStale: !this.isCacheValid(),\n      recentUserAction: this.recentUserAction,\n      totalElements: this.cache?.totalElements || 0\n    };\n  }\n\n  /**\n   * Fetch fresh data from GitHub\n   */\n  private async fetchFresh(): Promise<GitHubPortfolioIndex> {\n    const startTime = Date.now();\n    logger.info('Fetching fresh GitHub portfolio index...');\n    \n    try {\n      // Get GitHub username from token\n      const username = await this.getGitHubUsername();\n      const repository = 'dollhouse-portfolio';\n      \n      // Check if portfolio repository exists\n      const repoExists = await this.portfolioRepoManager.checkPortfolioExists(username);\n      if (!repoExists) {\n        logger.info('GitHub portfolio repository does not exist', { username });\n        return this.createEmptyIndex(username, repository);\n      }\n      \n      // Fetch repository content using GitHub API\n      const index = await this.fetchRepositoryContent(username, repository);\n      \n      // Update cache\n      this.cache = index;\n      this.lastFetch = new Date();\n      this.recentUserAction = false;\n      this.actionTimestamp = null;\n      \n      const duration = Date.now() - startTime;\n      logger.info('GitHub portfolio index fetched successfully', {\n        username,\n        totalElements: index.totalElements,\n        duration: `${duration}ms`,\n        rateLimitRemaining: index.rateLimitInfo?.remaining\n      });\n      \n      // Log security event\n      SecurityMonitor.logSecurityEvent({\n        type: 'PORTFOLIO_FETCH_SUCCESS',\n        severity: 'LOW',\n        source: 'GitHubPortfolioIndexer.fetchFresh',\n        details: `Fetched GitHub portfolio with ${index.totalElements} elements in ${duration}ms`,\n        metadata: { username, duration, totalElements: index.totalElements }\n      });\n      \n      return index;\n      \n    } catch (error) {\n      const duration = Date.now() - startTime;\n      ErrorHandler.logError('GitHubPortfolioIndexer.fetchFresh', error, { duration });\n      throw ErrorHandler.wrapError(error, 'Failed to fetch GitHub portfolio index', ErrorCategory.NETWORK_ERROR);\n    }\n  }\n\n  /**\n   * Fetch repository content from GitHub API\n   */\n  private async fetchRepositoryContent(username: string, repository: string): Promise<GitHubPortfolioIndex> {\n    // Try GraphQL first for better performance, fallback to REST\n    try {\n      return await this.fetchWithGraphQL(username, repository);\n    } catch (graphqlError) {\n      logger.debug('GraphQL fetch failed, falling back to REST API', {\n        error: graphqlError instanceof Error ? graphqlError.message : String(graphqlError)\n      });\n      \n      return await this.fetchWithREST(username, repository);\n    }\n  }\n\n  /**\n   * Fetch using GraphQL for better performance\n   */\n  private async fetchWithGraphQL(username: string, repository: string): Promise<GitHubPortfolioIndex> {\n    const query = `\n      query GetPortfolioContent($owner: String!, $name: String!) {\n        repository(owner: $owner, name: $name) {\n          defaultBranchRef {\n            target {\n              ... on Commit {\n                oid\n                history(first: 1) {\n                  nodes {\n                    committedDate\n                  }\n                }\n              }\n            }\n          }\n          object(expression: \"HEAD:\") {\n            ... on Tree {\n              entries {\n                name\n                type\n                object {\n                  ... on Tree {\n                    entries {\n                      name\n                      type\n                      oid\n                      object {\n                        ... on Blob {\n                          byteSize\n                          text\n                        }\n                      }\n                    }\n                  }\n                }\n              }\n            }\n          }\n        }\n        rateLimit {\n          remaining\n          resetAt\n        }\n      }\n    `;\n    \n    const variables = { owner: username, name: repository };\n    \n    const response = await this.githubClient.fetchFromGitHub('https://api.github.com/graphql', true);\n    \n    // Note: This is a simplified GraphQL implementation\n    // In a real implementation, you would send POST request with query and variables\n    throw new Error('GraphQL implementation not yet complete');\n  }\n\n  /**\n   * Fetch using REST API with pagination\n   */\n  private async fetchWithREST(username: string, repository: string): Promise<GitHubPortfolioIndex> {\n    const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;\n    \n    // Get repository info and latest commit\n    const repoInfo = await this.githubClient.fetchFromGitHub(\n      `https://api.github.com/repos/${normalizedUsername}/${repository}`\n    );\n    \n    const latestCommit = await this.githubClient.fetchFromGitHub(\n      `https://api.github.com/repos/${normalizedUsername}/${repository}/commits/HEAD`\n    );\n    \n    // Initialize index\n    const index: GitHubPortfolioIndex = {\n      username: normalizedUsername,\n      repository,\n      lastUpdated: new Date(latestCommit.commit.committer.date),\n      elements: new Map(),\n      totalElements: 0,\n      sha: latestCommit.sha\n    };\n    \n    // Initialize element type maps\n    for (const elementType of Object.values(ElementType)) {\n      index.elements.set(elementType, []);\n    }\n    \n    // Fetch content for each element type\n    for (const elementType of Object.values(ElementType)) {\n      try {\n        const entries = await this.fetchElementTypeContent(normalizedUsername, repository, elementType);\n        index.elements.set(elementType, entries);\n        index.totalElements += entries.length;\n      } catch (error) {\n        logger.warn(`Failed to fetch ${elementType} from GitHub portfolio`, {\n          error: error instanceof Error ? error.message : String(error)\n        });\n        // Continue with other element types\n      }\n    }\n    \n    return index;\n  }\n\n  /**\n   * Fetch content for a specific element type\n   */\n  private async fetchElementTypeContent(\n    username: string,\n    repository: string,\n    elementType: ElementType\n  ): Promise<GitHubIndexEntry[]> {\n    try {\n      // Get directory listing\n      const contents = await this.githubClient.fetchFromGitHub(\n        `https://api.github.com/repos/${username}/${repository}/contents/${elementType}`\n      );\n      \n      if (!Array.isArray(contents)) {\n        return [];\n      }\n      \n      const entries: GitHubIndexEntry[] = [];\n      const maxConcurrent = 5; // Limit concurrent requests\n      \n      // Process files in batches to avoid rate limiting\n      for (let i = 0; i < contents.length; i += maxConcurrent) {\n        const batch = contents.slice(i, i + maxConcurrent);\n        const batchPromises = batch\n          .filter(item => item.type === 'file' && item.name.endsWith('.md'))\n          .map(item => this.createGitHubIndexEntry(username, repository, elementType, item));\n        \n        const batchResults = await Promise.allSettled(batchPromises);\n        \n        for (const result of batchResults) {\n          if (result.status === 'fulfilled' && result.value) {\n            entries.push(result.value);\n          }\n        }\n        \n        // Add delay between batches to respect rate limits\n        if (i + maxConcurrent < contents.length) {\n          await new Promise(resolve => setTimeout(resolve, 100));\n        }\n      }\n      \n      return entries;\n      \n    } catch (error) {\n      // Directory might not exist\n      if (error instanceof Error && error.message.includes('404')) {\n        return [];\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Create GitHub index entry from API response\n   */\n  private async createGitHubIndexEntry(\n    username: string,\n    repository: string,\n    elementType: ElementType,\n    fileInfo: any\n  ): Promise<GitHubIndexEntry | null> {\n    try {\n      // Parse metadata from filename or fetch content if needed\n      const name = fileInfo.name.replace('.md', '').replace(/-/g, ' ');\n      \n      const entry: GitHubIndexEntry = {\n        path: fileInfo.path,\n        name,\n        elementType,\n        sha: fileInfo.sha,\n        htmlUrl: fileInfo.html_url,\n        downloadUrl: fileInfo.download_url,\n        lastModified: new Date(), // GitHub API doesn't provide file modification time directly\n        size: fileInfo.size || 0\n      };\n      \n      // Optionally fetch content to extract metadata\n      // This is expensive, so only do it for small files or when specifically needed\n      if (fileInfo.size && fileInfo.size < 10000) { // Only for files < 10KB\n        try {\n          const content = await this.githubClient.fetchFromGitHub(fileInfo.download_url);\n          const metadata = this.parseMetadataFromContent(content);\n          \n          if (metadata.name) entry.name = metadata.name;\n          if (metadata.description) entry.description = metadata.description;\n          if (metadata.version) entry.version = metadata.version;\n          if (metadata.author) entry.author = metadata.author;\n        } catch (metadataError) {\n          // Non-critical error, continue without metadata\n          logger.debug('Failed to fetch metadata for file', {\n            path: fileInfo.path,\n            error: metadataError instanceof Error ? metadataError.message : String(metadataError)\n          });\n        }\n      }\n      \n      return entry;\n      \n    } catch (error) {\n      logger.debug('Failed to create GitHub index entry', {\n        path: fileInfo.path,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      return null;\n    }\n  }\n\n  /**\n   * Parse metadata from file content (frontmatter)\n   */\n  private parseMetadataFromContent(content: string): {\n    name?: string;\n    description?: string;\n    version?: string;\n    author?: string;\n  } {\n    const metadata: any = {};\n    \n    // Simple frontmatter parsing (could use a proper YAML parser)\n    const frontmatterMatch = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n    if (frontmatterMatch) {\n      const frontmatter = frontmatterMatch[1];\n      \n      const nameMatch = frontmatter.match(/^name:\\s*(.+)$/m);\n      if (nameMatch) metadata.name = nameMatch[1].trim();\n      \n      const descMatch = frontmatter.match(/^description:\\s*(.+)$/m);\n      if (descMatch) metadata.description = descMatch[1].trim();\n      \n      const versionMatch = frontmatter.match(/^version:\\s*(.+)$/m);\n      if (versionMatch) metadata.version = versionMatch[1].trim();\n      \n      const authorMatch = frontmatter.match(/^author:\\s*(.+)$/m);\n      if (authorMatch) metadata.author = authorMatch[1].trim();\n    }\n    \n    return metadata;\n  }\n\n  /**\n   * Get GitHub username from authenticated token\n   */\n  private async getGitHubUsername(): Promise<string> {\n    try {\n      const userInfo = await this.githubClient.fetchFromGitHub('https://api.github.com/user', true);\n      return userInfo.login;\n    } catch (error) {\n      throw new Error('Failed to get GitHub username. Please ensure you are authenticated with GitHub.');\n    }\n  }\n\n  /**\n   * Check if cache is valid\n   */\n  private isCacheValid(): boolean {\n    if (!this.cache || !this.lastFetch) {\n      return false;\n    }\n    \n    const age = Date.now() - this.lastFetch.getTime();\n    return age < this.ttl;\n  }\n\n  /**\n   * Determine if we should fetch fresh data\n   */\n  private shouldFetchFresh(): boolean {\n    // Always fetch if no cache\n    if (!this.cache || !this.lastFetch) {\n      return true;\n    }\n    \n    // Check for recent user actions\n    if (this.recentUserAction && this.actionTimestamp) {\n      const actionAge = Date.now() - this.actionTimestamp.getTime();\n      if (actionAge < this.actionGracePeriod) {\n        logger.debug('Fetching fresh due to recent user action', { actionAge });\n        return true;\n      } else {\n        // Grace period expired, clear action flag\n        this.recentUserAction = false;\n        this.actionTimestamp = null;\n      }\n    }\n    \n    // Check TTL\n    return !this.isCacheValid();\n  }\n\n  /**\n   * Create empty index when no portfolio exists\n   */\n  private createEmptyIndex(username?: string, repository?: string): GitHubPortfolioIndex {\n    const index: GitHubPortfolioIndex = {\n      username: username || 'unknown',\n      repository: repository || 'dollhouse-portfolio',\n      lastUpdated: new Date(),\n      elements: new Map(),\n      totalElements: 0,\n      sha: ''\n    };\n    \n    // Initialize empty element type maps\n    for (const elementType of Object.values(ElementType)) {\n      index.elements.set(elementType, []);\n    }\n    \n    return index;\n  }\n}"]}

package/dist/portfolio/MigrationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MigrationManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/MigrationManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzC,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,gBAAgB,EAAE,gBAAgB;IAI9C;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ/C;;OAEG;IACU,OAAO,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IA2E9E;;OAEG;YACW,cAAc;IAiC5B;;OAEG;YACW,YAAY;IAuB1B;;OAEG;IACU,kBAAkB,IAAI,OAAO,CAAC;QACzC,iBAAiB,EAAE,OAAO,CAAC;QAC3B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;KAC7C,CAAC;CAsBH"}
+{"version":3,"file":"MigrationManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/MigrationManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAOzC,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,gBAAgB,EAAE,gBAAgB;IAI9C;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ/C;;OAEG;IACU,OAAO,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IA8I9E;;OAEG;YACW,cAAc;IA6F5B;;OAEG;YACW,YAAY;IAwC1B;;OAEG;IACU,kBAAkB,IAAI,OAAO,CAAC;QACzC,iBAAiB,EAAE,OAAO,CAAC;QAC3B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;KAC7C,CAAC;CAsBH"}