@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/portfolio/PortfolioIndexManager.js

@@ -0,0 +1,478 @@
+/**
+ * Portfolio Index Manager - Maps element names to file paths
+ *
+ * Solves critical issues:
+ * 1. submit_content can't find elements by metadata name (e.g., "Safe Roundtrip Tester" -> "safe-roundtrip-tester.md")
+ * 2. search_collection doesn't search local portfolio content
+ *
+ * Features:
+ * - In-memory index mapping metadata.name → file path
+ * - Keywords/tags → file paths mapping
+ * - Element type → file paths mapping
+ * - Fast O(1) lookups with Maps
+ * - Lazy loading with 5-minute TTL cache
+ * - Unicode normalization for security
+ * - Error handling and logging
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { ElementType } from './types.js';
+import { PortfolioManager } from './PortfolioManager.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';
+export class PortfolioIndexManager {
+    static instance = null;
+    static instanceLock = false;
+    index = null;
+    lastBuilt = null;
+    TTL_MS = 5 * 60 * 1000; // 5 minutes
+    isBuilding = false;
+    buildPromise = null;
+    constructor() {
+        logger.debug('PortfolioIndexManager created');
+    }
+    static getInstance() {
+        if (!this.instance) {
+            if (this.instanceLock) {
+                throw new Error('PortfolioIndexManager instance is being created by another thread');
+            }
+            try {
+                this.instanceLock = true;
+                this.instance = new PortfolioIndexManager();
+            }
+            finally {
+                this.instanceLock = false;
+            }
+        }
+        return this.instance;
+    }
+    /**
+     * Get the current index, building it if necessary
+     */
+    async getIndex() {
+        // Check if we need to rebuild
+        if (this.needsRebuild()) {
+            await this.buildIndex();
+        }
+        return this.index;
+    }
+    /**
+     * Search the portfolio index by name with fuzzy matching
+     */
+    async findByName(name, options = {}) {
+        const index = await this.getIndex();
+        // Normalize input for security
+        const normalizedName = UnicodeValidator.normalize(name);
+        if (!normalizedName.isValid) {
+            logger.warn('Invalid Unicode in search name', {
+                issues: normalizedName.detectedIssues
+            });
+            return null;
+        }
+        const safeName = normalizedName.normalizedContent;
+        // Try exact match first (case insensitive)
+        const exactMatch = index.byName.get(safeName.toLowerCase());
+        if (exactMatch) {
+            logger.debug('Found exact name match', { name: safeName, filePath: exactMatch.filePath });
+            return exactMatch;
+        }
+        // Try filename match
+        const filenameMatch = index.byFilename.get(safeName.toLowerCase());
+        if (filenameMatch) {
+            logger.debug('Found filename match', { name: safeName, filePath: filenameMatch.filePath });
+            return filenameMatch;
+        }
+        // Try fuzzy matching if enabled
+        if (options.fuzzyMatch !== false) {
+            const fuzzyMatch = this.findFuzzyMatch(safeName, index, options);
+            if (fuzzyMatch) {
+                logger.debug('Found fuzzy match', {
+                    name: safeName,
+                    matchName: fuzzyMatch.metadata.name,
+                    filePath: fuzzyMatch.filePath
+                });
+                return fuzzyMatch;
+            }
+        }
+        logger.debug('No match found for name', { name: safeName });
+        return null;
+    }
+    /**
+     * Search the portfolio with comprehensive text search
+     */
+    async search(query, options = {}) {
+        const index = await this.getIndex();
+        // Normalize query for security
+        const normalizedQuery = UnicodeValidator.normalize(query);
+        if (!normalizedQuery.isValid) {
+            logger.warn('Invalid Unicode in search query', {
+                issues: normalizedQuery.detectedIssues
+            });
+            return [];
+        }
+        const safeQuery = normalizedQuery.normalizedContent.toLowerCase().trim();
+        const queryTokens = safeQuery.split(/\s+/).filter(token => token.length > 0);
+        if (queryTokens.length === 0) {
+            return [];
+        }
+        const results = [];
+        const seenPaths = new Set();
+        const maxResults = options.maxResults || 20;
+        // Helper to add unique results
+        const addResult = (entry, matchType, score = 1) => {
+            if (!seenPaths.has(entry.filePath) && results.length < maxResults) {
+                // Filter by element type if specified
+                if (options.elementType && entry.elementType !== options.elementType) {
+                    return;
+                }
+                seenPaths.add(entry.filePath);
+                results.push({ entry, matchType, score });
+            }
+        };
+        // 1. Search by name (highest priority)
+        for (const [name, entry] of index.byName) {
+            if (this.matchesQuery(name, queryTokens)) {
+                addResult(entry, 'name', 3);
+            }
+        }
+        // 2. Search by filename
+        for (const [filename, entry] of index.byFilename) {
+            if (this.matchesQuery(filename, queryTokens)) {
+                addResult(entry, 'filename', 2.5);
+            }
+        }
+        // 3. Search by keywords
+        if (options.includeKeywords !== false) {
+            for (const [keyword, entries] of index.byKeyword) {
+                if (this.matchesQuery(keyword, queryTokens)) {
+                    for (const entry of entries) {
+                        addResult(entry, 'keyword', 2);
+                    }
+                }
+            }
+        }
+        // 4. Search by tags
+        if (options.includeTags !== false) {
+            for (const [tag, entries] of index.byTag) {
+                if (this.matchesQuery(tag, queryTokens)) {
+                    for (const entry of entries) {
+                        addResult(entry, 'tag', 2);
+                    }
+                }
+            }
+        }
+        // 5. Search by triggers
+        if (options.includeTriggers !== false) {
+            for (const [trigger, entries] of index.byTrigger) {
+                if (this.matchesQuery(trigger, queryTokens)) {
+                    for (const entry of entries) {
+                        addResult(entry, 'trigger', 1.8);
+                    }
+                }
+            }
+        }
+        // 6. Search by description
+        if (options.includeDescriptions !== false) {
+            for (const [_, entry] of index.byName) {
+                if (entry.metadata.description &&
+                    this.matchesQuery(entry.metadata.description.toLowerCase(), queryTokens)) {
+                    addResult(entry, 'description', 1.5);
+                }
+            }
+        }
+        // Sort by score (descending)
+        results.sort((a, b) => b.score - a.score);
+        logger.debug('Portfolio search completed', {
+            query: safeQuery,
+            resultCount: results.length,
+            totalIndexed: index.byName.size
+        });
+        return results;
+    }
+    /**
+     * Get all elements of a specific type
+     */
+    async getElementsByType(elementType) {
+        const index = await this.getIndex();
+        return index.byType.get(elementType) || [];
+    }
+    /**
+     * Get statistics about the index
+     */
+    async getStats() {
+        const index = await this.getIndex();
+        const stats = {
+            totalElements: index.byName.size,
+            elementsByType: {},
+            lastBuilt: this.lastBuilt,
+            isStale: this.needsRebuild()
+        };
+        for (const elementType of Object.values(ElementType)) {
+            stats.elementsByType[elementType] = (index.byType.get(elementType) || []).length;
+        }
+        return stats;
+    }
+    /**
+     * Force rebuild the index
+     */
+    async rebuildIndex() {
+        this.index = null;
+        this.lastBuilt = null;
+        await this.buildIndex();
+    }
+    /**
+     * Check if the index needs rebuilding
+     */
+    needsRebuild() {
+        if (!this.index || !this.lastBuilt) {
+            return true;
+        }
+        const age = Date.now() - this.lastBuilt.getTime();
+        return age > this.TTL_MS;
+    }
+    /**
+     * Build the index by scanning all portfolio directories
+     */
+    async buildIndex() {
+        // Prevent concurrent builds
+        if (this.isBuilding) {
+            if (this.buildPromise) {
+                await this.buildPromise;
+            }
+            return;
+        }
+        this.isBuilding = true;
+        this.buildPromise = this.performBuild();
+        try {
+            await this.buildPromise;
+        }
+        finally {
+            this.isBuilding = false;
+            this.buildPromise = null;
+        }
+    }
+    /**
+     * Perform the actual index building
+     */
+    async performBuild() {
+        const startTime = Date.now();
+        logger.info('Building portfolio index...');
+        try {
+            const portfolioManager = PortfolioManager.getInstance();
+            // Initialize empty index
+            const newIndex = {
+                byName: new Map(),
+                byFilename: new Map(),
+                byType: new Map(),
+                byKeyword: new Map(),
+                byTag: new Map(),
+                byTrigger: new Map()
+            };
+            // Initialize type maps
+            for (const elementType of Object.values(ElementType)) {
+                newIndex.byType.set(elementType, []);
+            }
+            let totalFiles = 0;
+            let processedFiles = 0;
+            // Scan each element type
+            for (const elementType of Object.values(ElementType)) {
+                try {
+                    const elementDir = portfolioManager.getElementDir(elementType);
+                    // Check if directory exists
+                    try {
+                        await fs.access(elementDir);
+                    }
+                    catch {
+                        logger.debug(`Element directory doesn't exist: ${elementDir}`);
+                        continue;
+                    }
+                    const files = await fs.readdir(elementDir);
+                    const mdFiles = files.filter(file => file.endsWith('.md'));
+                    totalFiles += mdFiles.length;
+                    for (const file of mdFiles) {
+                        try {
+                            const filePath = path.join(elementDir, file);
+                            const entry = await this.createIndexEntry(filePath, elementType);
+                            if (entry) {
+                                this.addToIndex(newIndex, entry);
+                                processedFiles++;
+                            }
+                        }
+                        catch (error) {
+                            logger.warn(`Failed to index file: ${file}`, {
+                                elementType,
+                                error: error instanceof Error ? error.message : String(error)
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error(`Failed to scan element type: ${elementType}`, {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Update instance state
+            this.index = newIndex;
+            this.lastBuilt = new Date();
+            const duration = Date.now() - startTime;
+            logger.info('Portfolio index built successfully', {
+                totalFiles,
+                processedFiles,
+                duration: `${duration}ms`,
+                uniqueNames: newIndex.byName.size,
+                uniqueKeywords: newIndex.byKeyword.size,
+                uniqueTags: newIndex.byTag.size
+            });
+            // Log security event for audit trail
+            SecurityMonitor.logSecurityEvent({
+                type: 'PORTFOLIO_INITIALIZATION',
+                severity: 'LOW',
+                source: 'PortfolioIndexManager.performBuild',
+                details: `Portfolio index rebuilt with ${processedFiles} elements in ${duration}ms`
+            });
+        }
+        catch (error) {
+            ErrorHandler.logError('PortfolioIndexManager.performBuild', error);
+            throw ErrorHandler.wrapError(error, 'Failed to build portfolio index', ErrorCategory.SYSTEM_ERROR);
+        }
+    }
+    /**
+     * Create an index entry from a file
+     */
+    async createIndexEntry(filePath, elementType) {
+        try {
+            // Get file stats
+            const stats = await fs.stat(filePath);
+            // Read file content
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Parse frontmatter securely
+            const parsed = SecureYamlParser.parse(content);
+            // Extract base filename
+            const filename = path.basename(filePath, '.md');
+            // Build metadata with defaults
+            const metadata = {
+                name: parsed.data.name || filename,
+                description: parsed.data.description,
+                version: parsed.data.version,
+                author: parsed.data.author,
+                tags: Array.isArray(parsed.data.tags) ? parsed.data.tags : [],
+                keywords: Array.isArray(parsed.data.keywords) ? parsed.data.keywords : [],
+                triggers: Array.isArray(parsed.data.triggers) ? parsed.data.triggers : [],
+                category: parsed.data.category,
+                created: parsed.data.created || parsed.data.created_date,
+                updated: parsed.data.updated || parsed.data.updated_date
+            };
+            const entry = {
+                filePath,
+                elementType,
+                metadata,
+                lastModified: stats.mtime,
+                filename
+            };
+            return entry;
+        }
+        catch (error) {
+            logger.debug(`Failed to create index entry for: ${filePath}`, {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return null;
+        }
+    }
+    /**
+     * Add entry to all relevant index maps
+     */
+    addToIndex(index, entry) {
+        // Normalize keys for case-insensitive lookup
+        const normalizedName = entry.metadata.name.toLowerCase();
+        const normalizedFilename = entry.filename.toLowerCase();
+        // Add to name map
+        index.byName.set(normalizedName, entry);
+        // Add to filename map
+        index.byFilename.set(normalizedFilename, entry);
+        // Add to type map
+        const typeEntries = index.byType.get(entry.elementType) || [];
+        typeEntries.push(entry);
+        index.byType.set(entry.elementType, typeEntries);
+        // Add keywords
+        for (const keyword of entry.metadata.keywords || []) {
+            const normalizedKeyword = keyword.toLowerCase();
+            const keywordEntries = index.byKeyword.get(normalizedKeyword) || [];
+            keywordEntries.push(entry);
+            index.byKeyword.set(normalizedKeyword, keywordEntries);
+        }
+        // Add tags
+        for (const tag of entry.metadata.tags || []) {
+            const normalizedTag = tag.toLowerCase();
+            const tagEntries = index.byTag.get(normalizedTag) || [];
+            tagEntries.push(entry);
+            index.byTag.set(normalizedTag, tagEntries);
+        }
+        // Add triggers
+        for (const trigger of entry.metadata.triggers || []) {
+            const normalizedTrigger = trigger.toLowerCase();
+            const triggerEntries = index.byTrigger.get(normalizedTrigger) || [];
+            triggerEntries.push(entry);
+            index.byTrigger.set(normalizedTrigger, triggerEntries);
+        }
+    }
+    /**
+     * Find fuzzy matches for a name
+     */
+    findFuzzyMatch(searchName, index, options) {
+        const search = searchName.toLowerCase();
+        let bestMatch = null;
+        let bestScore = 0;
+        // Search names with partial matching
+        for (const [name, entry] of index.byName) {
+            if (options.elementType && entry.elementType !== options.elementType) {
+                continue;
+            }
+            const score = this.calculateSimilarity(search, name);
+            if (score > bestScore && score > 0.3) { // Minimum similarity threshold
+                bestScore = score;
+                bestMatch = entry;
+            }
+        }
+        // Also check filenames
+        for (const [filename, entry] of index.byFilename) {
+            if (options.elementType && entry.elementType !== options.elementType) {
+                continue;
+            }
+            const score = this.calculateSimilarity(search, filename);
+            if (score > bestScore && score > 0.3) {
+                bestScore = score;
+                bestMatch = entry;
+            }
+        }
+        return bestMatch;
+    }
+    /**
+     * Calculate similarity between two strings
+     */
+    calculateSimilarity(a, b) {
+        // Simple similarity based on substring containment and length
+        if (a === b)
+            return 1.0;
+        if (a.includes(b) || b.includes(a))
+            return 0.8;
+        // Check for word overlap
+        const wordsA = a.split(/\s+/);
+        const wordsB = b.split(/\s+/);
+        const commonWords = wordsA.filter(word => wordsB.includes(word));
+        if (commonWords.length > 0) {
+            return commonWords.length / Math.max(wordsA.length, wordsB.length);
+        }
+        return 0;
+    }
+    /**
+     * Check if any query tokens match the text
+     */
+    matchesQuery(text, queryTokens) {
+        return queryTokens.some(token => text.includes(token));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioIndexManager.js","sourceRoot":"","sources":["../../src/portfolio/PortfolioIndexManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Portfolio Index Manager - Maps element names to file paths\n * \n * Solves critical issues:\n * 1. submit_content can't find elements by metadata name (e.g., \"Safe Roundtrip Tester\" -> \"safe-roundtrip-tester.md\")\n * 2. search_collection doesn't search local portfolio content\n * \n * Features:\n * - In-memory index mapping metadata.name → file path\n * - Keywords/tags → file paths mapping\n * - Element type → file paths mapping\n * - Fast O(1) lookups with Maps\n * - Lazy loading with 5-minute TTL cache\n * - Unicode normalization for security\n * - Error handling and logging\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from '../utils/logger.js';\nimport { ElementType } from './types.js';\nimport { PortfolioManager } from './PortfolioManager.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\n\nexport interface IndexEntry {\n  filePath: string;\n  elementType: ElementType;\n  metadata: {\n    name: string;\n    description?: string;\n    version?: string;\n    author?: string;\n    tags?: string[];\n    keywords?: string[];\n    triggers?: string[];\n    category?: string;\n    created?: string;\n    updated?: string;\n  };\n  lastModified: Date;\n  filename: string; // Base filename without extension\n}\n\nexport interface PortfolioIndex {\n  byName: Map<string, IndexEntry>;\n  byFilename: Map<string, IndexEntry>;\n  byType: Map<ElementType, IndexEntry[]>;\n  byKeyword: Map<string, IndexEntry[]>;\n  byTag: Map<string, IndexEntry[]>;\n  byTrigger: Map<string, IndexEntry[]>;\n}\n\nexport interface SearchOptions {\n  elementType?: ElementType;\n  fuzzyMatch?: boolean;\n  maxResults?: number;\n  includeKeywords?: boolean;\n  includeTags?: boolean;\n  includeTriggers?: boolean;\n  includeDescriptions?: boolean;\n}\n\nexport interface SearchResult {\n  entry: IndexEntry;\n  matchType: 'name' | 'filename' | 'keyword' | 'tag' | 'trigger' | 'description';\n  score: number; // For future ranking\n}\n\nexport class PortfolioIndexManager {\n  private static instance: PortfolioIndexManager | null = null;\n  private static instanceLock = false;\n  \n  private index: PortfolioIndex | null = null;\n  private lastBuilt: Date | null = null;\n  private readonly TTL_MS = 5 * 60 * 1000; // 5 minutes\n  private isBuilding = false;\n  private buildPromise: Promise<void> | null = null;\n\n  private constructor() {\n    logger.debug('PortfolioIndexManager created');\n  }\n\n  public static getInstance(): PortfolioIndexManager {\n    if (!this.instance) {\n      if (this.instanceLock) {\n        throw new Error('PortfolioIndexManager instance is being created by another thread');\n      }\n      \n      try {\n        this.instanceLock = true;\n        this.instance = new PortfolioIndexManager();\n      } finally {\n        this.instanceLock = false;\n      }\n    }\n    return this.instance;\n  }\n\n  /**\n   * Get the current index, building it if necessary\n   */\n  public async getIndex(): Promise<PortfolioIndex> {\n    // Check if we need to rebuild\n    if (this.needsRebuild()) {\n      await this.buildIndex();\n    }\n    \n    return this.index!;\n  }\n\n  /**\n   * Search the portfolio index by name with fuzzy matching\n   */\n  public async findByName(name: string, options: SearchOptions = {}): Promise<IndexEntry | null> {\n    const index = await this.getIndex();\n    \n    // Normalize input for security\n    const normalizedName = UnicodeValidator.normalize(name);\n    if (!normalizedName.isValid) {\n      logger.warn('Invalid Unicode in search name', {\n        issues: normalizedName.detectedIssues\n      });\n      return null;\n    }\n    \n    const safeName = normalizedName.normalizedContent;\n    \n    // Try exact match first (case insensitive)\n    const exactMatch = index.byName.get(safeName.toLowerCase());\n    if (exactMatch) {\n      logger.debug('Found exact name match', { name: safeName, filePath: exactMatch.filePath });\n      return exactMatch;\n    }\n    \n    // Try filename match\n    const filenameMatch = index.byFilename.get(safeName.toLowerCase());\n    if (filenameMatch) {\n      logger.debug('Found filename match', { name: safeName, filePath: filenameMatch.filePath });\n      return filenameMatch;\n    }\n    \n    // Try fuzzy matching if enabled\n    if (options.fuzzyMatch !== false) {\n      const fuzzyMatch = this.findFuzzyMatch(safeName, index, options);\n      if (fuzzyMatch) {\n        logger.debug('Found fuzzy match', { \n          name: safeName, \n          matchName: fuzzyMatch.metadata.name,\n          filePath: fuzzyMatch.filePath \n        });\n        return fuzzyMatch;\n      }\n    }\n    \n    logger.debug('No match found for name', { name: safeName });\n    return null;\n  }\n\n  /**\n   * Search the portfolio with comprehensive text search\n   */\n  public async search(query: string, options: SearchOptions = {}): Promise<SearchResult[]> {\n    const index = await this.getIndex();\n    \n    // Normalize query for security\n    const normalizedQuery = UnicodeValidator.normalize(query);\n    if (!normalizedQuery.isValid) {\n      logger.warn('Invalid Unicode in search query', {\n        issues: normalizedQuery.detectedIssues\n      });\n      return [];\n    }\n    \n    const safeQuery = normalizedQuery.normalizedContent.toLowerCase().trim();\n    const queryTokens = safeQuery.split(/\\s+/).filter(token => token.length > 0);\n    \n    if (queryTokens.length === 0) {\n      return [];\n    }\n    \n    const results: SearchResult[] = [];\n    const seenPaths = new Set<string>();\n    const maxResults = options.maxResults || 20;\n    \n    // Helper to add unique results\n    const addResult = (entry: IndexEntry, matchType: SearchResult['matchType'], score: number = 1) => {\n      if (!seenPaths.has(entry.filePath) && results.length < maxResults) {\n        // Filter by element type if specified\n        if (options.elementType && entry.elementType !== options.elementType) {\n          return;\n        }\n        \n        seenPaths.add(entry.filePath);\n        results.push({ entry, matchType, score });\n      }\n    };\n    \n    // 1. Search by name (highest priority)\n    for (const [name, entry] of index.byName) {\n      if (this.matchesQuery(name, queryTokens)) {\n        addResult(entry, 'name', 3);\n      }\n    }\n    \n    // 2. Search by filename\n    for (const [filename, entry] of index.byFilename) {\n      if (this.matchesQuery(filename, queryTokens)) {\n        addResult(entry, 'filename', 2.5);\n      }\n    }\n    \n    // 3. Search by keywords\n    if (options.includeKeywords !== false) {\n      for (const [keyword, entries] of index.byKeyword) {\n        if (this.matchesQuery(keyword, queryTokens)) {\n          for (const entry of entries) {\n            addResult(entry, 'keyword', 2);\n          }\n        }\n      }\n    }\n    \n    // 4. Search by tags\n    if (options.includeTags !== false) {\n      for (const [tag, entries] of index.byTag) {\n        if (this.matchesQuery(tag, queryTokens)) {\n          for (const entry of entries) {\n            addResult(entry, 'tag', 2);\n          }\n        }\n      }\n    }\n    \n    // 5. Search by triggers\n    if (options.includeTriggers !== false) {\n      for (const [trigger, entries] of index.byTrigger) {\n        if (this.matchesQuery(trigger, queryTokens)) {\n          for (const entry of entries) {\n            addResult(entry, 'trigger', 1.8);\n          }\n        }\n      }\n    }\n    \n    // 6. Search by description\n    if (options.includeDescriptions !== false) {\n      for (const [_, entry] of index.byName) {\n        if (entry.metadata.description && \n            this.matchesQuery(entry.metadata.description.toLowerCase(), queryTokens)) {\n          addResult(entry, 'description', 1.5);\n        }\n      }\n    }\n    \n    // Sort by score (descending)\n    results.sort((a, b) => b.score - a.score);\n    \n    logger.debug('Portfolio search completed', {\n      query: safeQuery,\n      resultCount: results.length,\n      totalIndexed: index.byName.size\n    });\n    \n    return results;\n  }\n\n  /**\n   * Get all elements of a specific type\n   */\n  public async getElementsByType(elementType: ElementType): Promise<IndexEntry[]> {\n    const index = await this.getIndex();\n    return index.byType.get(elementType) || [];\n  }\n\n  /**\n   * Get statistics about the index\n   */\n  public async getStats(): Promise<{\n    totalElements: number;\n    elementsByType: Record<ElementType, number>;\n    lastBuilt: Date | null;\n    isStale: boolean;\n  }> {\n    const index = await this.getIndex();\n    const stats = {\n      totalElements: index.byName.size,\n      elementsByType: {} as Record<ElementType, number>,\n      lastBuilt: this.lastBuilt,\n      isStale: this.needsRebuild()\n    };\n    \n    for (const elementType of Object.values(ElementType)) {\n      stats.elementsByType[elementType] = (index.byType.get(elementType) || []).length;\n    }\n    \n    return stats;\n  }\n\n  /**\n   * Force rebuild the index\n   */\n  public async rebuildIndex(): Promise<void> {\n    this.index = null;\n    this.lastBuilt = null;\n    await this.buildIndex();\n  }\n\n  /**\n   * Check if the index needs rebuilding\n   */\n  private needsRebuild(): boolean {\n    if (!this.index || !this.lastBuilt) {\n      return true;\n    }\n    \n    const age = Date.now() - this.lastBuilt.getTime();\n    return age > this.TTL_MS;\n  }\n\n  /**\n   * Build the index by scanning all portfolio directories\n   */\n  private async buildIndex(): Promise<void> {\n    // Prevent concurrent builds\n    if (this.isBuilding) {\n      if (this.buildPromise) {\n        await this.buildPromise;\n      }\n      return;\n    }\n    \n    this.isBuilding = true;\n    \n    this.buildPromise = this.performBuild();\n    \n    try {\n      await this.buildPromise;\n    } finally {\n      this.isBuilding = false;\n      this.buildPromise = null;\n    }\n  }\n\n  /**\n   * Perform the actual index building\n   */\n  private async performBuild(): Promise<void> {\n    const startTime = Date.now();\n    logger.info('Building portfolio index...');\n    \n    try {\n      const portfolioManager = PortfolioManager.getInstance();\n      \n      // Initialize empty index\n      const newIndex: PortfolioIndex = {\n        byName: new Map(),\n        byFilename: new Map(),\n        byType: new Map(),\n        byKeyword: new Map(),\n        byTag: new Map(),\n        byTrigger: new Map()\n      };\n      \n      // Initialize type maps\n      for (const elementType of Object.values(ElementType)) {\n        newIndex.byType.set(elementType, []);\n      }\n      \n      let totalFiles = 0;\n      let processedFiles = 0;\n      \n      // Scan each element type\n      for (const elementType of Object.values(ElementType)) {\n        try {\n          const elementDir = portfolioManager.getElementDir(elementType);\n          \n          // Check if directory exists\n          try {\n            await fs.access(elementDir);\n          } catch {\n            logger.debug(`Element directory doesn't exist: ${elementDir}`);\n            continue;\n          }\n          \n          const files = await fs.readdir(elementDir);\n          const mdFiles = files.filter(file => file.endsWith('.md'));\n          totalFiles += mdFiles.length;\n          \n          for (const file of mdFiles) {\n            try {\n              const filePath = path.join(elementDir, file);\n              const entry = await this.createIndexEntry(filePath, elementType);\n              \n              if (entry) {\n                this.addToIndex(newIndex, entry);\n                processedFiles++;\n              }\n            } catch (error) {\n              logger.warn(`Failed to index file: ${file}`, {\n                elementType,\n                error: error instanceof Error ? error.message : String(error)\n              });\n            }\n          }\n        } catch (error) {\n          logger.error(`Failed to scan element type: ${elementType}`, {\n            error: error instanceof Error ? error.message : String(error)\n          });\n        }\n      }\n      \n      // Update instance state\n      this.index = newIndex;\n      this.lastBuilt = new Date();\n      \n      const duration = Date.now() - startTime;\n      logger.info('Portfolio index built successfully', {\n        totalFiles,\n        processedFiles,\n        duration: `${duration}ms`,\n        uniqueNames: newIndex.byName.size,\n        uniqueKeywords: newIndex.byKeyword.size,\n        uniqueTags: newIndex.byTag.size\n      });\n      \n      // Log security event for audit trail\n      SecurityMonitor.logSecurityEvent({\n        type: 'PORTFOLIO_INITIALIZATION',\n        severity: 'LOW',\n        source: 'PortfolioIndexManager.performBuild',\n        details: `Portfolio index rebuilt with ${processedFiles} elements in ${duration}ms`\n      });\n      \n    } catch (error) {\n      ErrorHandler.logError('PortfolioIndexManager.performBuild', error);\n      throw ErrorHandler.wrapError(error, 'Failed to build portfolio index', ErrorCategory.SYSTEM_ERROR);\n    }\n  }\n\n  /**\n   * Create an index entry from a file\n   */\n  private async createIndexEntry(filePath: string, elementType: ElementType): Promise<IndexEntry | null> {\n    try {\n      // Get file stats\n      const stats = await fs.stat(filePath);\n      \n      // Read file content\n      const content = await fs.readFile(filePath, 'utf-8');\n      \n      // Parse frontmatter securely\n      const parsed = SecureYamlParser.parse(content);\n      \n      // Extract base filename\n      const filename = path.basename(filePath, '.md');\n      \n      // Build metadata with defaults\n      const metadata = {\n        name: parsed.data.name || filename,\n        description: parsed.data.description,\n        version: parsed.data.version,\n        author: parsed.data.author,\n        tags: Array.isArray(parsed.data.tags) ? parsed.data.tags : [],\n        keywords: Array.isArray(parsed.data.keywords) ? parsed.data.keywords : [],\n        triggers: Array.isArray(parsed.data.triggers) ? parsed.data.triggers : [],\n        category: parsed.data.category,\n        created: parsed.data.created || parsed.data.created_date,\n        updated: parsed.data.updated || parsed.data.updated_date\n      };\n      \n      const entry: IndexEntry = {\n        filePath,\n        elementType,\n        metadata,\n        lastModified: stats.mtime,\n        filename\n      };\n      \n      return entry;\n      \n    } catch (error) {\n      logger.debug(`Failed to create index entry for: ${filePath}`, {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      return null;\n    }\n  }\n\n  /**\n   * Add entry to all relevant index maps\n   */\n  private addToIndex(index: PortfolioIndex, entry: IndexEntry): void {\n    // Normalize keys for case-insensitive lookup\n    const normalizedName = entry.metadata.name.toLowerCase();\n    const normalizedFilename = entry.filename.toLowerCase();\n    \n    // Add to name map\n    index.byName.set(normalizedName, entry);\n    \n    // Add to filename map\n    index.byFilename.set(normalizedFilename, entry);\n    \n    // Add to type map\n    const typeEntries = index.byType.get(entry.elementType) || [];\n    typeEntries.push(entry);\n    index.byType.set(entry.elementType, typeEntries);\n    \n    // Add keywords\n    for (const keyword of entry.metadata.keywords || []) {\n      const normalizedKeyword = keyword.toLowerCase();\n      const keywordEntries = index.byKeyword.get(normalizedKeyword) || [];\n      keywordEntries.push(entry);\n      index.byKeyword.set(normalizedKeyword, keywordEntries);\n    }\n    \n    // Add tags\n    for (const tag of entry.metadata.tags || []) {\n      const normalizedTag = tag.toLowerCase();\n      const tagEntries = index.byTag.get(normalizedTag) || [];\n      tagEntries.push(entry);\n      index.byTag.set(normalizedTag, tagEntries);\n    }\n    \n    // Add triggers\n    for (const trigger of entry.metadata.triggers || []) {\n      const normalizedTrigger = trigger.toLowerCase();\n      const triggerEntries = index.byTrigger.get(normalizedTrigger) || [];\n      triggerEntries.push(entry);\n      index.byTrigger.set(normalizedTrigger, triggerEntries);\n    }\n  }\n\n  /**\n   * Find fuzzy matches for a name\n   */\n  private findFuzzyMatch(searchName: string, index: PortfolioIndex, options: SearchOptions): IndexEntry | null {\n    const search = searchName.toLowerCase();\n    let bestMatch: IndexEntry | null = null;\n    let bestScore = 0;\n    \n    // Search names with partial matching\n    for (const [name, entry] of index.byName) {\n      if (options.elementType && entry.elementType !== options.elementType) {\n        continue;\n      }\n      \n      const score = this.calculateSimilarity(search, name);\n      if (score > bestScore && score > 0.3) { // Minimum similarity threshold\n        bestScore = score;\n        bestMatch = entry;\n      }\n    }\n    \n    // Also check filenames\n    for (const [filename, entry] of index.byFilename) {\n      if (options.elementType && entry.elementType !== options.elementType) {\n        continue;\n      }\n      \n      const score = this.calculateSimilarity(search, filename);\n      if (score > bestScore && score > 0.3) {\n        bestScore = score;\n        bestMatch = entry;\n      }\n    }\n    \n    return bestMatch;\n  }\n\n  /**\n   * Calculate similarity between two strings\n   */\n  private calculateSimilarity(a: string, b: string): number {\n    // Simple similarity based on substring containment and length\n    if (a === b) return 1.0;\n    if (a.includes(b) || b.includes(a)) return 0.8;\n    \n    // Check for word overlap\n    const wordsA = a.split(/\\s+/);\n    const wordsB = b.split(/\\s+/);\n    const commonWords = wordsA.filter(word => wordsB.includes(word));\n    \n    if (commonWords.length > 0) {\n      return commonWords.length / Math.max(wordsA.length, wordsB.length);\n    }\n    \n    return 0;\n  }\n\n  /**\n   * Check if any query tokens match the text\n   */\n  private matchesQuery(text: string, queryTokens: string[]): boolean {\n    return queryTokens.some(token => text.includes(token));\n  }\n}"]}

package/dist/portfolio/PortfolioManager.d.ts

@@ -33,6 +33,11 @@ export declare class PortfolioManager {
      * Check if portfolio directory exists
      */
     exists(): Promise<boolean>;
+    /**
+     * Check if a filename appears to be a test element
+     * SAFETY: Pattern-based filtering only, no content parsing
+     */
+    isTestElement(filename: string): boolean;
     /**
      * List all elements of a specific type
      */

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

@@ -1 +1 @@
-{"version":3,"file":"PortfolioManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/PortfolioManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAQ1D,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAC1C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAS;IACpC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAS;IAC1C,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAA8B;IAClE,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;WA4BO,WAAW,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,gBAAgB;IAiBrE;;OAEG;IACI,UAAU,IAAI,MAAM;IAI3B;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAI/C;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBxC;;OAEG;YACW,qBAAqB;IAiDnC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IASvC;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA4C/D;;OAEG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IA0ClE;;OAEG;IACU,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASjF;;OAEG;IACI,oBAAoB,IAAI,MAAM;IAIrC;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAUlD;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAWlE;;;OAGG;YACW,8BAA8B;CA+D7C"}
+{"version":3,"file":"PortfolioManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/PortfolioManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAS1D,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAC1C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAS;IACpC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAS;IAC1C,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAA8B;IAClE,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;WA4BO,WAAW,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,gBAAgB;IAiBrE;;OAEG;IACI,UAAU,IAAI,MAAM;IAI3B;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAI/C;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBxC;;OAEG;YACW,qBAAqB;IAiDnC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IASvC;;;OAGG;IACI,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAgD/C;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAoC/D;;OAEG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IA0ClE;;OAEG;IACU,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASjF;;OAEG;IACI,oBAAoB,IAAI,MAAM;IAIrC;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAUlD;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAWlE;;;OAGG;YACW,8BAA8B;CA+D7C"}