codebase-context 1.6.2 → 1.8.0

package/dist/core/indexer.js

@@ -2,20 +2,153 @@
  * Core Indexer - Orchestrates codebase indexing
  * Scans files, delegates to analyzers, creates embeddings, stores in vector DB
  */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+import { randomUUID } from 'crypto';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { glob } from 'glob';
 import ignore from 'ignore';
 import { analyzerRegistry } from './analyzer-registry.js';
 import { isCodeFile, isBinaryFile } from '../utils/language-detection.js';
-import { getEmbeddingProvider, DEFAULT_MODEL } from '../embeddings/index.js';
+import { getEmbeddingProvider, getConfiguredDimensions, DEFAULT_MODEL, parseEmbeddingProviderName } from '../embeddings/index.js';
 import { getStorageProvider } from '../storage/index.js';
 import { LibraryUsageTracker, PatternDetector, ImportGraph, InternalFileGraph } from '../utils/usage-tracker.js';
 import { mergeSmallChunks } from '../utils/chunking.js';
 import { getFileCommitDates } from '../utils/git-dates.js';
-import { CODEBASE_CONTEXT_DIRNAME, INDEXING_STATS_FILENAME, INTELLIGENCE_FILENAME, KEYWORD_INDEX_FILENAME, MANIFEST_FILENAME, VECTOR_DB_DIRNAME } from '../constants/codebase-context.js';
+import { CODEBASE_CONTEXT_DIRNAME, INDEX_FORMAT_VERSION, INDEXING_STATS_FILENAME, INDEX_META_FILENAME, INDEX_META_VERSION, INTELLIGENCE_FILENAME, KEYWORD_INDEX_FILENAME, MANIFEST_FILENAME, RELATIONSHIPS_FILENAME, VECTOR_DB_DIRNAME } from '../constants/codebase-context.js';
+const STAGING_DIRNAME = '.staging';
+const PREVIOUS_DIRNAME = '.previous';
 import { computeFileHashes, readManifest, writeManifest, diffManifest } from './manifest.js';
+import { readIndexMeta, checkEmbeddingMismatch } from './index-meta.js';
+let cachedToolVersion = null;
+async function getToolVersion() {
+    if (cachedToolVersion)
+        return cachedToolVersion;
+    try {
+        const pkgRaw = await fs.readFile(new URL('../../package.json', import.meta.url), 'utf-8');
+        const pkg = JSON.parse(pkgRaw);
+        if (typeof pkg.version === 'string' && pkg.version.trim()) {
+            cachedToolVersion = pkg.version;
+            return cachedToolVersion;
+        }
+    }
+    catch {
+        // Best-effort — fall back below
+    }
+    cachedToolVersion = 'unknown';
+    return cachedToolVersion;
+}
+/**
+ * Perform a Windows-safe atomic swap of staging artifacts into active location.
+ * Strategy: move current active to .previous, then rename staging to active.
+ * If staging rename fails, restore from .previous.
+ */
+async function atomicSwapStagingToActive(contextDir, stagingDir, buildId) {
+    const previousDir = path.join(contextDir, PREVIOUS_DIRNAME);
+    const activeMetaPath = path.join(contextDir, INDEX_META_FILENAME);
+    const activeIndexPath = path.join(contextDir, KEYWORD_INDEX_FILENAME);
+    const activeIntelligencePath = path.join(contextDir, INTELLIGENCE_FILENAME);
+    const activeVectorDir = path.join(contextDir, VECTOR_DB_DIRNAME);
+    const activeManifestPath = path.join(contextDir, MANIFEST_FILENAME);
+    const activeStatsPath = path.join(contextDir, INDEXING_STATS_FILENAME);
+    const activeRelationshipsPath = path.join(contextDir, RELATIONSHIPS_FILENAME);
+    const stagingMetaPath = path.join(stagingDir, INDEX_META_FILENAME);
+    const stagingIndexPath = path.join(stagingDir, KEYWORD_INDEX_FILENAME);
+    const stagingIntelligencePath = path.join(stagingDir, INTELLIGENCE_FILENAME);
+    const stagingVectorDir = path.join(stagingDir, VECTOR_DB_DIRNAME);
+    const stagingManifestPath = path.join(stagingDir, MANIFEST_FILENAME);
+    const stagingStatsPath = path.join(stagingDir, INDEXING_STATS_FILENAME);
+    const stagingRelationshipsPath = path.join(stagingDir, RELATIONSHIPS_FILENAME);
+    // Step 1: Create .previous directory and move current active there
+    await fs.mkdir(previousDir, { recursive: true });
+    const moveIfExists = async (src, dest) => {
+        try {
+            await fs.rename(src, dest);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                // File doesn't exist is OK, other errors are problems
+                throw error;
+            }
+        }
+    };
+    const moveDirIfExists = async (src, dest) => {
+        try {
+            const stat = await fs.stat(src);
+            if (stat.isDirectory()) {
+                await fs.rename(src, dest);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    };
+    // Move active artifacts to .previous
+    await moveIfExists(activeMetaPath, path.join(previousDir, INDEX_META_FILENAME));
+    await moveIfExists(activeIndexPath, path.join(previousDir, KEYWORD_INDEX_FILENAME));
+    await moveIfExists(activeIntelligencePath, path.join(previousDir, INTELLIGENCE_FILENAME));
+    await moveIfExists(activeManifestPath, path.join(previousDir, MANIFEST_FILENAME));
+    await moveIfExists(activeStatsPath, path.join(previousDir, INDEXING_STATS_FILENAME));
+    await moveIfExists(activeRelationshipsPath, path.join(previousDir, RELATIONSHIPS_FILENAME));
+    await moveDirIfExists(activeVectorDir, path.join(previousDir, VECTOR_DB_DIRNAME));
+    // Step 2: Move staging artifacts to active location
+    try {
+        await moveIfExists(stagingMetaPath, activeMetaPath);
+        await moveIfExists(stagingIndexPath, activeIndexPath);
+        await moveIfExists(stagingIntelligencePath, activeIntelligencePath);
+        await moveIfExists(stagingManifestPath, activeManifestPath);
+        await moveIfExists(stagingStatsPath, activeStatsPath);
+        await moveIfExists(stagingRelationshipsPath, activeRelationshipsPath);
+        await moveDirIfExists(stagingVectorDir, activeVectorDir);
+        // Step 3: Clean up .previous and staging directories
+        await cleanupDirectory(previousDir);
+        await cleanupDirectory(stagingDir);
+        // Also clean up the parent .staging/ directory if empty
+        const stagingBase = path.join(contextDir, STAGING_DIRNAME);
+        try {
+            const remaining = await fs.readdir(stagingBase);
+            if (remaining.length === 0) {
+                await fs.rmdir(stagingBase);
+            }
+        }
+        catch {
+            // Directory doesn't exist or not empty - ignore
+        }
+        console.error(`Atomic swap complete: build ${buildId} now active`);
+    }
+    catch (swapError) {
+        console.error('Atomic swap failed, attempting rollback:', swapError);
+        // Attempt rollback: restore from .previous
+        try {
+            await moveIfExists(path.join(previousDir, INDEX_META_FILENAME), activeMetaPath);
+            await moveIfExists(path.join(previousDir, KEYWORD_INDEX_FILENAME), activeIndexPath);
+            await moveIfExists(path.join(previousDir, INTELLIGENCE_FILENAME), activeIntelligencePath);
+            await moveIfExists(path.join(previousDir, MANIFEST_FILENAME), activeManifestPath);
+            await moveIfExists(path.join(previousDir, INDEXING_STATS_FILENAME), activeStatsPath);
+            await moveIfExists(path.join(previousDir, RELATIONSHIPS_FILENAME), activeRelationshipsPath);
+            await moveDirIfExists(path.join(previousDir, VECTOR_DB_DIRNAME), activeVectorDir);
+            console.error('Rollback successful');
+        }
+        catch (rollbackError) {
+            console.error('Rollback also failed:', rollbackError);
+        }
+        throw swapError;
+    }
+}
+/**
+ * Best-effort cleanup of a directory and its contents.
+ */
+async function cleanupDirectory(dirPath) {
+    try {
+        await fs.rm(dirPath, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort: ignore cleanup failures
+    }
+}
 export class CodebaseIndexer {
     rootPath;
     config;
@@ -38,6 +171,13 @@ export class CodebaseIndexer {
         };
     }
     mergeConfig(userConfig) {
+        const defaultEmbeddingProvider = parseEmbeddingProviderName(process.env.EMBEDDING_PROVIDER) ?? 'transformers';
+        // When provider=openai and EMBEDDING_MODEL is not set, DEFAULT_MODEL resolves to the
+        // transformers fallback (Xenova/bge-small-en-v1.5), which the OpenAI API rejects.
+        // Use a sane OpenAI default instead.
+        const defaultModel = defaultEmbeddingProvider === 'openai' && !process.env.EMBEDDING_MODEL
+            ? 'text-embedding-3-small'
+            : DEFAULT_MODEL;
         const defaultConfig = {
             analyzers: {
                 angular: { enabled: true, priority: 100 },
@@ -45,8 +185,25 @@ export class CodebaseIndexer {
                 vue: { enabled: false, priority: 90 },
                 generic: { enabled: true, priority: 10 }
             },
-            include: ['**/*.{ts,tsx,js,jsx,html,css,scss,sass,less}'],
-            exclude: ['node_modules/**', 'dist/**', 'build/**', '.git/**', 'coverage/**'],
+            include: [
+                '**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}',
+                '**/*.{html,htm,css,scss,sass,less}',
+                '**/*.{py,pyi,rb,php}',
+                '**/*.{java,kt,kts,scala,swift,cs}',
+                '**/*.{go,rs}',
+                '**/*.{c,cpp,cc,cxx,h,hpp}',
+                '**/*.{sh,bash,zsh,ps1}',
+                '**/*.{sql,graphql,gql}',
+                '**/*.{json,jsonc,yaml,yml,toml,xml}'
+            ],
+            exclude: [
+                'node_modules/**',
+                'dist/**',
+                'build/**',
+                '.git/**',
+                'coverage/**',
+                '.codebase-context/**'
+            ],
             respectGitignore: true,
             parsing: {
                 maxFileSize: 1048576,
@@ -66,8 +223,8 @@ export class CodebaseIndexer {
                 includeChangelogs: false
             },
             embedding: {
-                provider: 'transformers',
-                model: DEFAULT_MODEL,
+                provider: defaultEmbeddingProvider,
+                model: defaultModel,
                 batchSize: 32
             },
             skipEmbedding: false,
@@ -115,7 +272,17 @@ export class CodebaseIndexer {
             errors: [],
             startedAt: new Date()
         };
+        let stagingDir = null;
         try {
+            // Ensure there is at least a generic fallback analyzer registered when the indexer
+            // is used directly (e.g. in tests or standalone scripts).
+            if (analyzerRegistry.getAll().length === 0) {
+                const { GenericAnalyzer } = await import('../analyzers/generic/index.js');
+                analyzerRegistry.register(new GenericAnalyzer());
+            }
+            const buildId = randomUUID();
+            const generatedAt = new Date().toISOString();
+            const toolVersion = await getToolVersion();
             // Phase 1: Scanning
             this.updateProgress('scanning', 0);
             let files = await this.scanFiles();
@@ -150,8 +317,26 @@ export class CodebaseIndexer {
                     deleted: diff.deleted.length,
                     unchanged: diff.unchanged.length
                 };
+                // Check for embedding provider/model mismatch — forces full rebuild to avoid
+                // silent vector dimension mismatch when switching providers or models.
+                try {
+                    const existingMeta = await readIndexMeta(this.rootPath);
+                    const currentProvider = this.config.embedding?.provider ?? 'transformers';
+                    const currentModel = this.config.embedding?.model ?? DEFAULT_MODEL;
+                    if (checkEmbeddingMismatch(existingMeta, currentProvider, currentModel)) {
+                        const stored = existingMeta.artifacts.vectorDb;
+                        console.error(`Embedding provider/model changed (stored: ${stored.embeddingProvider}:${stored.embeddingModel}, current: ${currentProvider}:${currentModel}) — forcing full rebuild`);
+                        diff = null;
+                    }
+                }
+                catch {
+                    // No meta yet or legacy index without embedding fields — proceed with incremental
+                }
                 // Short-circuit: nothing changed
-                if (diff.added.length === 0 && diff.changed.length === 0 && diff.deleted.length === 0) {
+                if (diff &&
+                    diff.added.length === 0 &&
+                    diff.changed.length === 0 &&
+                    diff.deleted.length === 0) {
                     console.error('No files changed - skipping re-index.');
                     this.updateProgress('complete', 100);
                     stats.duration = Date.now() - startTime;
@@ -177,7 +362,13 @@ export class CodebaseIndexer {
                         }
                         try {
                             const existingIndexPath = path.join(contextDir, KEYWORD_INDEX_FILENAME);
-                            const existingChunks = JSON.parse(await fs.readFile(existingIndexPath, 'utf-8'));
+                            const existing = JSON.parse(await fs.readFile(existingIndexPath, 'utf-8'));
+                            const existingObj = existing;
+                            const existingChunks = Array.isArray(existing)
+                                ? existing
+                                : existingObj && Array.isArray(existingObj.chunks)
+                                    ? existingObj.chunks
+                                    : null;
                             if (Array.isArray(existingChunks)) {
                                 stats.totalChunks = existingChunks.length;
                                 if (stats.indexedFiles === 0) {
@@ -253,7 +444,7 @@ export class CodebaseIndexer {
                                         break;
                                     }
                                 }
-                                internalFileGraph.trackImport(file, resolvedPath, imp.imports);
+                                internalFileGraph.trackImport(file, resolvedPath, imp.line || 1, imp.imports);
                             }
                         }
                         // Track exports for unused export detection
@@ -285,7 +476,8 @@ export class CodebaseIndexer {
                         // GENERIC PATTERN FORWARDING
                         // Framework analyzers return detectedPatterns in metadata - we just forward them
                         // This keeps the indexer framework-agnostic
-                        if (result.metadata?.detectedPatterns) {
+                        if (result.metadata?.detectedPatterns &&
+                            Array.isArray(result.metadata.detectedPatterns)) {
                             for (const pattern of result.metadata.detectedPatterns) {
                                 // Try to extract a relevant snippet for the pattern
                                 // Ask analyzer registry for snippet pattern (framework-agnostic delegation)
@@ -297,7 +489,10 @@ export class CodebaseIndexer {
                         }
                         // Track file for Golden File scoring (framework-agnostic)
                         // A golden file = file with patterns in ≥3 distinct categories
-                        const detectedPatterns = result.metadata?.detectedPatterns || [];
+                        const rawPatterns = result.metadata?.detectedPatterns;
+                        const detectedPatterns = Array.isArray(rawPatterns)
+                            ? rawPatterns
+                            : [];
                         const uniqueCategories = new Set(detectedPatterns.map((p) => p.category));
                         const patternScore = uniqueCategories.size;
                         if (patternScore >= 3) {
@@ -305,7 +500,7 @@ export class CodebaseIndexer {
                             for (const p of detectedPatterns) {
                                 patternFlags[`${p.category}:${p.name}`] = true;
                             }
-                            patternDetector.trackGoldenFile(relPath, patternScore, patternFlags); // TODO: fix type;
+                            patternDetector.trackGoldenFile(relPath, patternScore, patternFlags);
                         }
                         // Update component statistics
                         for (const component of result.components) {
@@ -404,10 +599,22 @@ export class CodebaseIndexer {
             }
             // Phase 4: Storing
             this.updateProgress('storing', 75);
-            await fs.mkdir(contextDir, { recursive: true });
+            // For full rebuilds, use staging directory for atomic swap
+            // For incremental, write directly to active location
+            const isFullRebuild = !diff;
+            let activeContextDir = contextDir;
+            if (isFullRebuild) {
+                // Create staging directory for atomic swap
+                const stagingBase = path.join(contextDir, STAGING_DIRNAME);
+                stagingDir = path.join(stagingBase, buildId);
+                await fs.mkdir(stagingDir, { recursive: true });
+                activeContextDir = stagingDir;
+                console.error(`Full rebuild: writing to staging ${stagingDir}`);
+            }
+            await fs.mkdir(activeContextDir, { recursive: true });
             if (!this.config.skipEmbedding) {
-                const storagePath = path.join(contextDir, VECTOR_DB_DIRNAME);
-                const storageProvider = await getStorageProvider({ path: storagePath });
+                const storagePath = path.join(activeContextDir, VECTOR_DB_DIRNAME);
+                const storageProvider = await getStorageProvider({ path: storagePath }, diff ? { expectedDimensions: getConfiguredDimensions(this.config.embedding) } : undefined);
                 if (diff) {
                     // Incremental: delete old chunks for changed + deleted files, then add new
                     const filesToDelete = [...diff.changed, ...diff.deleted].map((rel) => path.join(this.rootPath, rel).replace(/\\/g, '/'));
@@ -424,19 +631,26 @@ export class CodebaseIndexer {
                         `added ${chunksWithEmbeddings.length} new chunks`);
                 }
                 else {
-                    // Full: clear and re-store everything
-                    console.error(`Storing ${chunksToEmbed.length} chunks...`);
-                    await storageProvider.clear();
+                    // Full rebuild: store to staging (no clear - fresh directory)
+                    console.error(`Storing ${chunksToEmbed.length} chunks to staging...`);
                     await storageProvider.store(chunksWithEmbeddings);
                 }
             }
+            // Vector DB build marker (required for version gating)
+            // Write after semantic store step so marker reflects the latest DB state.
+            const vectorDir = path.join(activeContextDir, VECTOR_DB_DIRNAME);
+            await fs.mkdir(vectorDir, { recursive: true });
+            await fs.writeFile(path.join(vectorDir, 'index-build.json'), JSON.stringify({ buildId, formatVersion: INDEX_FORMAT_VERSION }));
             // Keyword index always uses ALL chunks (full regen)
-            const indexPath = path.join(contextDir, KEYWORD_INDEX_FILENAME);
+            const indexPath = path.join(activeContextDir, KEYWORD_INDEX_FILENAME);
             // Memory safety: cap keyword index too
             const keywordChunks = allChunks.length > MAX_CHUNKS ? allChunks.slice(0, MAX_CHUNKS) : allChunks;
-            await fs.writeFile(indexPath, JSON.stringify(keywordChunks));
+            await fs.writeFile(indexPath, JSON.stringify({
+                header: { buildId, formatVersion: INDEX_FORMAT_VERSION },
+                chunks: keywordChunks
+            }));
             // Save library usage and pattern stats (always full regen)
-            const intelligencePath = path.join(contextDir, INTELLIGENCE_FILENAME);
+            const intelligencePath = path.join(activeContextDir, INTELLIGENCE_FILENAME);
             const libraryStats = libraryTracker.getStats();
             // Extract tsconfig paths for AI to understand import aliases
             let tsconfigPaths;
@@ -453,6 +667,7 @@ export class CodebaseIndexer {
                 // No tsconfig.json or no paths defined
             }
             const intelligence = {
+                header: { buildId, formatVersion: INDEX_FORMAT_VERSION },
                 libraryUsage: libraryStats,
                 patterns: patternDetector.getAllPatterns(),
                 goldenFiles: patternDetector.getGoldenFiles(5),
@@ -465,23 +680,97 @@ export class CodebaseIndexer {
                 },
                 // Internal file graph for circular dependency and unused export detection
                 internalFileGraph: internalFileGraph.toJSON(),
-                generatedAt: new Date().toISOString()
+                generatedAt
             };
             await fs.writeFile(intelligencePath, JSON.stringify(intelligence, null, 2));
+            // Write relationships sidecar (versioned, for fast lookup)
+            const relationshipsPath = path.join(activeContextDir, RELATIONSHIPS_FILENAME);
+            const graphData = internalFileGraph.toJSON();
+            // Build reverse import map (importedBy)
+            const importedBy = {};
+            if (graphData.imports) {
+                for (const [file, deps] of Object.entries(graphData.imports)) {
+                    for (const dep of deps) {
+                        if (!importedBy[dep])
+                            importedBy[dep] = [];
+                        importedBy[dep].push(file);
+                    }
+                }
+            }
+            // Build symbol export map (exportedBy)
+            const exportedBy = {};
+            if (graphData.exports) {
+                for (const [file, exps] of Object.entries(graphData.exports)) {
+                    for (const exp of exps) {
+                        if (exp.name && exp.name !== 'default') {
+                            if (!exportedBy[exp.name])
+                                exportedBy[exp.name] = [];
+                            if (!exportedBy[exp.name].includes(file)) {
+                                exportedBy[exp.name].push(file);
+                            }
+                        }
+                    }
+                }
+            }
+            const relationships = {
+                header: { buildId, formatVersion: INDEX_FORMAT_VERSION },
+                generatedAt,
+                graph: {
+                    imports: graphData.imports || {},
+                    ...(graphData.importDetails ? { importDetails: graphData.importDetails } : {}),
+                    importedBy,
+                    exports: graphData.exports || {}
+                },
+                symbols: {
+                    exportedBy
+                },
+                stats: graphData.stats || internalFileGraph.getStats()
+            };
+            await fs.writeFile(relationshipsPath, JSON.stringify(relationships, null, 2));
             // Write manifest (both full and incremental)
+            // For full rebuild, write to staging; for incremental, write to active
+            const activeManifestPath = path.join(activeContextDir, MANIFEST_FILENAME);
             const manifest = {
                 version: 1,
                 generatedAt: new Date().toISOString(),
                 files: currentHashes ?? (await computeFileHashes(files, this.rootPath))
             };
-            await writeManifest(manifestPath, manifest);
+            await writeManifest(activeManifestPath, manifest);
             const persistedStats = {
                 indexedFiles: stats.indexedFiles,
                 totalChunks: stats.totalChunks,
                 totalFiles: stats.totalFiles,
-                generatedAt: new Date().toISOString()
+                generatedAt
             };
-            await fs.writeFile(indexingStatsPath, JSON.stringify(persistedStats, null, 2));
+            const activeIndexingStatsPath = path.join(activeContextDir, INDEXING_STATS_FILENAME);
+            await fs.writeFile(activeIndexingStatsPath, JSON.stringify(persistedStats, null, 2));
+            // Index meta (authoritative) — write last so readers never observe meta pointing to missing artifacts.
+            const metaPath = path.join(activeContextDir, INDEX_META_FILENAME);
+            await fs.writeFile(metaPath, JSON.stringify({
+                metaVersion: INDEX_META_VERSION,
+                formatVersion: INDEX_FORMAT_VERSION,
+                buildId,
+                generatedAt,
+                toolVersion,
+                artifacts: {
+                    keywordIndex: { path: KEYWORD_INDEX_FILENAME },
+                    vectorDb: {
+                        path: VECTOR_DB_DIRNAME,
+                        provider: 'lancedb',
+                        embeddingProvider: this.config.embedding?.provider ?? 'transformers',
+                        embeddingModel: this.config.embedding?.model ?? DEFAULT_MODEL
+                    },
+                    intelligence: { path: INTELLIGENCE_FILENAME },
+                    manifest: { path: MANIFEST_FILENAME },
+                    indexingStats: { path: INDEXING_STATS_FILENAME },
+                    relationships: { path: RELATIONSHIPS_FILENAME }
+                }
+            }, null, 2));
+            // Atomic swap for full rebuilds: move staging into active location
+            if (isFullRebuild && stagingDir) {
+                console.error('Performing atomic swap of staging to active...');
+                await atomicSwapStagingToActive(contextDir, stagingDir, buildId);
+            }
             // Phase 5: Complete
             this.updateProgress('complete', 100);
             stats.duration = Date.now() - startTime;
@@ -505,6 +794,11 @@ export class CodebaseIndexer {
                 phase: this.progress.phase,
                 timestamp: new Date()
             });
+            // Clean up staging directory on failure (best-effort)
+            if (stagingDir) {
+                console.error('Cleaning up staging directory after failure...');
+                await cleanupDirectory(stagingDir);
+            }
             throw error;
         }
     }
@@ -636,6 +930,10 @@ export class CodebaseIndexer {
             const intelligencePath = path.join(this.rootPath, CODEBASE_CONTEXT_DIRNAME, INTELLIGENCE_FILENAME);
             const intelligenceContent = await fs.readFile(intelligencePath, 'utf-8');
             const intelligence = JSON.parse(intelligenceContent);
+            // Phase 06: ignore legacy intelligence files that lack a versioned header.
+            if (!intelligence || typeof intelligence !== 'object' || !intelligence.header) {
+                return metadata;
+            }
             metadata.customMetadata = {
                 ...metadata.customMetadata,
                 libraryUsage: intelligence.libraryUsage,