ai-prompt-guide-mcp 1.0.0

package/dist/shared/addressing-system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressing-system.js","sourceRoot":"","sources":["../../src/shared/addressing-system.ts"],"names":[],"mappings":"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"}

package/dist/shared/document-analysis/__tests__/keyword-utils.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unit tests for enhanced keyword extraction utilities
+ *
+ * Tests the keyword extraction and weighting functionality including
+ * frontmatter parsing, weighted extraction, and backward compatibility.
+ */
+export {};
+//# sourceMappingURL=keyword-utils.test.d.ts.map

package/dist/shared/document-analysis/__tests__/keyword-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyword-utils.test.d.ts","sourceRoot":"","sources":["../../../../src/shared/document-analysis/__tests__/keyword-utils.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/shared/document-analysis/__tests__/keyword-utils.test.js

@@ -0,0 +1,601 @@
+/**
+ * Unit tests for enhanced keyword extraction utilities
+ *
+ * Tests the keyword extraction and weighting functionality including
+ * frontmatter parsing, weighted extraction, and backward compatibility.
+ */
+import { describe, it, expect } from 'vitest';
+import { extractWeightedKeywords, extractKeywordsWithFingerprint, calculateWeightedRelevance, calculateWeightedRelevanceWithBreakdown, generateFactorBasedExplanation, extractKeywords, calculateNamespaceAffinity, calculateRecencyBoost, calculateTitleSimilarity, calculateLinkGraphBoost, DEFAULT_KEYWORD_WEIGHTS, DEFAULT_SCORING_FEATURES } from '../keyword-utils.js';
+describe('Enhanced Keyword Utilities', () => {
+    describe('extractWeightedKeywords', () => {
+        it('should extract keywords from title and content', () => {
+            const result = extractWeightedKeywords('User Authentication API', 'This document describes JWT authentication for user management');
+            expect(result.keywords).toContain('user');
+            expect(result.keywords).toContain('authentication');
+            expect(result.keywords).toContain('api');
+            expect(result.hasExplicitKeywords).toBe(false);
+            expect(result.totalWeight).toBeGreaterThan(0);
+        });
+        it('should parse explicit frontmatter keywords', () => {
+            const content = `---
+keywords: [auth, api, security, jwt]
+title: Authentication Guide
+---
+
+# Authentication
+
+This guide covers user authentication.`;
+            const result = extractWeightedKeywords('Authentication API', content);
+            expect(result.hasExplicitKeywords).toBe(true);
+            expect(result.keywords).toEqual(['auth', 'api', 'security', 'jwt']);
+            expect(result.weightedKeywords).toHaveLength(4);
+            expect(result.weightedKeywords[0]?.weight).toBe(DEFAULT_KEYWORD_WEIGHTS.frontmatter);
+            expect(result.weightedKeywords[0]?.sources).toEqual(['frontmatter']);
+        });
+        it('should handle quoted frontmatter keywords', () => {
+            const content = `---
+keywords: "authentication, api, security"
+---
+
+# Content`;
+            const result = extractWeightedKeywords('Title', content);
+            expect(result.hasExplicitKeywords).toBe(true);
+            expect(result.keywords).toEqual(['authentication', 'api', 'security']);
+        });
+        it('should extract weighted keywords from different content sources', () => {
+            const content = `# Main Heading
+
+This **important** content describes _emphasized_ features.
+
+## Sub Heading
+
+Regular content with keywords.`;
+            const result = extractWeightedKeywords('Document Title', content);
+            expect(result.hasExplicitKeywords).toBe(false);
+            expect(result.weightedKeywords.length).toBeGreaterThan(0);
+            // Check that different sources have different weights
+            const titleKeywords = result.weightedKeywords.filter(wk => wk.sources.includes('title'));
+            const headingKeywords = result.weightedKeywords.filter(wk => wk.sources.includes('headings'));
+            const emphasisKeywords = result.weightedKeywords.filter(wk => wk.sources.includes('emphasis'));
+            expect(titleKeywords.length).toBeGreaterThan(0);
+            expect(headingKeywords.length).toBeGreaterThan(0);
+            expect(emphasisKeywords.length).toBeGreaterThan(0);
+            // Title should have higher weight than regular content
+            if (titleKeywords[0] != null) {
+                expect(titleKeywords[0].weight).toBe(DEFAULT_KEYWORD_WEIGHTS.title);
+            }
+        });
+        it('should handle empty input gracefully', () => {
+            const result = extractWeightedKeywords('', '');
+            expect(result.keywords).toEqual([]);
+            expect(result.weightedKeywords).toEqual([]);
+            expect(result.hasExplicitKeywords).toBe(false);
+            expect(result.totalWeight).toBe(0);
+        });
+        it('should use custom weights when provided', () => {
+            const customWeights = {
+                frontmatter: 10.0,
+                title: 5.0,
+                headings: 3.0,
+                emphasis: 2.0,
+                content: 1.0
+            };
+            const result = extractWeightedKeywords('Test Title', 'Content', customWeights);
+            const titleKeywords = result.weightedKeywords.filter(wk => wk.sources.includes('title'));
+            if (titleKeywords[0] != null) {
+                expect(titleKeywords[0].weight).toBe(5.0);
+            }
+        });
+    });
+    describe('extractKeywordsWithFingerprint', () => {
+        it('should prefer content analysis when content is available', () => {
+            const fingerprint = {
+                keywords: ['old', 'cached'],
+                namespace: 'test',
+                lastModified: new Date(),
+                contentHash: 'hash123'
+            };
+            const result = extractKeywordsWithFingerprint('New Title', 'New content with different keywords', fingerprint);
+            expect(result.keywords).toContain('new');
+            expect(result.keywords).not.toContain('old');
+        });
+        it('should fall back to fingerprint when no content available', () => {
+            const fingerprint = {
+                keywords: ['cached', 'keywords'],
+                namespace: 'test',
+                lastModified: new Date(),
+                contentHash: 'hash123'
+            };
+            const result = extractKeywordsWithFingerprint('Title', null, fingerprint);
+            expect(result.keywords).toContain('cached');
+            expect(result.keywords).toContain('keywords');
+            expect(result.weightedKeywords[0]?.sources).toEqual(['fingerprint']);
+        });
+        it('should handle missing fingerprint gracefully', () => {
+            const result = extractKeywordsWithFingerprint('Test Title', null, undefined);
+            expect(result.keywords).toContain('test');
+            expect(result.keywords).toContain('title');
+        });
+    });
+    describe('calculateWeightedRelevance (legacy compatibility)', () => {
+        it('should calculate relevance using multi-factor scoring', () => {
+            const sourceKeywords = [
+                { keyword: 'api', weight: 3.0, sources: ['title'] },
+                { keyword: 'auth', weight: 5.0, sources: ['frontmatter'] },
+                { keyword: 'user', weight: 2.0, sources: ['headings'] }
+            ];
+            const relevance = calculateWeightedRelevance(sourceKeywords, 'Source API Documentation', // sourceTitle
+            'api/guides', // sourceNamespace
+            'API guide content', // sourceContent
+            'Authentication API Guide', // targetTitle
+            'This guide covers user authentication and API security', // targetContent
+            'api/specs', // targetNamespace
+            new Date(), // targetLastModified
+            '/api/specs/auth.md' // targetPath
+            );
+            expect(relevance).toBeGreaterThan(0);
+            expect(relevance).toBeLessThanOrEqual(1);
+        });
+        it('should return 0 for no keyword matches', () => {
+            const sourceKeywords = [
+                { keyword: 'database', weight: 3.0, sources: ['title'] }
+            ];
+            // Use an old date to avoid recency boost
+            const oldDate = new Date('2020-01-01');
+            const relevance = calculateWeightedRelevance(sourceKeywords, 'Database Guide', // sourceTitle
+            'data/guides', // sourceNamespace
+            'Database guide content', // sourceContent
+            'Frontend UI', // targetTitle
+            'User interface components and styling', // targetContent
+            'frontend/ui', // targetNamespace
+            oldDate, // targetLastModified (old to avoid recency boost)
+            '/frontend/ui.md' // targetPath
+            );
+            expect(relevance).toBe(0);
+        });
+        it('should handle empty source keywords', () => {
+            // Use an old date to avoid recency boost
+            const oldDate = new Date('2020-01-01');
+            const relevance = calculateWeightedRelevance([], 'Any Title', // sourceTitle
+            'any/namespace', // sourceNamespace
+            'Any content', // sourceContent
+            'Target Title', // targetTitle
+            'Target content', // targetContent
+            'target/namespace', // targetNamespace
+            oldDate, // targetLastModified (old to avoid recency boost)
+            '/target.md' // targetPath
+            );
+            expect(relevance).toBe(0);
+        });
+    });
+    describe('extractKeywords (backward compatibility)', () => {
+        it('should maintain backward compatibility with original behavior', () => {
+            const keywords = extractKeywords('User Authentication API', 'This API handles user login and session management');
+            expect(Array.isArray(keywords)).toBe(true);
+            expect(keywords).toContain('user');
+            expect(keywords).toContain('authentication');
+            expect(keywords).toContain('api');
+            // Should filter out short words and stop words
+            expect(keywords).not.toContain('and');
+            expect(keywords).not.toContain('the');
+        });
+        it('should handle empty inputs gracefully', () => {
+            const keywords = extractKeywords('', '');
+            expect(keywords).toEqual([]);
+        });
+        it('should provide fallback on extraction failure', () => {
+            // Test with input that might cause issues
+            const keywords = extractKeywords('Test', 'Content');
+            expect(Array.isArray(keywords)).toBe(true);
+        });
+    });
+    describe('frontmatter parsing', () => {
+        it('should handle malformed YAML gracefully', () => {
+            const content = `---
+keywords: [incomplete
+---
+
+# Content`;
+            const result = extractWeightedKeywords('Title', content);
+            // Should fall back to content analysis
+            expect(result.hasExplicitKeywords).toBe(false);
+            expect(result.keywords.length).toBeGreaterThan(0);
+        });
+        it('should ignore non-keyword frontmatter fields', () => {
+            const content = `---
+title: "Document Title"
+date: 2025-01-01
+keywords: [test, keywords]
+description: "Some description"
+---
+
+# Content`;
+            const result = extractWeightedKeywords('Title', content);
+            expect(result.hasExplicitKeywords).toBe(true);
+            expect(result.keywords).toEqual(['test', 'keywords']);
+        });
+    });
+    describe('performance and edge cases', () => {
+        it('should handle large content efficiently', () => {
+            const largeContent = 'word '.repeat(10000);
+            const start = Date.now();
+            const result = extractWeightedKeywords('Title', largeContent);
+            const duration = Date.now() - start;
+            expect(duration).toBeLessThan(1000); // Should complete within 1 second
+            expect(result.keywords.length).toBeLessThanOrEqual(50); // Should limit results
+        });
+        it('should handle unicode and special characters', () => {
+            const result = extractWeightedKeywords('Café API Documentation', 'Content with émojis 🚀 and spéciàl characters');
+            expect(result.keywords.length).toBeGreaterThan(0);
+            // Should handle unicode gracefully without throwing errors
+        });
+        it('should deduplicate keywords from multiple sources', () => {
+            const content = `# API Documentation
+
+This **API** guide covers API implementation details.`;
+            const result = extractWeightedKeywords('API Guide', content);
+            // 'api' should appear only once despite being in title, heading, emphasis, and content
+            const apiKeywords = result.keywords.filter(k => k === 'api');
+            expect(apiKeywords).toHaveLength(1);
+            // But it should have the highest weight from multiple sources
+            const apiWeighted = result.weightedKeywords.find(wk => wk.keyword === 'api');
+            expect(apiWeighted).toBeDefined();
+            expect(apiWeighted?.sources.length).toBeGreaterThan(1);
+        });
+    });
+    describe('Multi-factor Relevance Scoring', () => {
+        describe('calculateNamespaceAffinity', () => {
+            it('should return 0.2 for exact namespace match', () => {
+                const affinity = calculateNamespaceAffinity('api/specs', 'api/specs');
+                expect(affinity).toBe(0.2);
+            });
+            it('should return 0.15 for parent-child relationships', () => {
+                // Parent contains child
+                expect(calculateNamespaceAffinity('api', 'api/guides')).toBe(0.15);
+                // Child in parent
+                expect(calculateNamespaceAffinity('api/guides', 'api')).toBe(0.15);
+            });
+            it('should return 0.1 for sibling relationships', () => {
+                const affinity = calculateNamespaceAffinity('api/specs', 'api/guides');
+                expect(affinity).toBe(0.1);
+            });
+            it('should return 0.0 for unrelated namespaces', () => {
+                const affinity = calculateNamespaceAffinity('api', 'frontend');
+                expect(affinity).toBe(0.0);
+            });
+            it('should handle edge cases gracefully', () => {
+                expect(calculateNamespaceAffinity('', 'api')).toBe(0.0);
+                expect(calculateNamespaceAffinity('api', '')).toBe(0.0);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(calculateNamespaceAffinity(null, 'api')).toBe(0.0);
+            });
+            it('should handle root namespace properly', () => {
+                expect(calculateNamespaceAffinity('root', 'root')).toBe(0.2);
+                expect(calculateNamespaceAffinity('root', 'api')).toBe(0.0);
+            });
+        });
+        describe('calculateRecencyBoost', () => {
+            const now = new Date();
+            const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+            const lastWeek = new Date(now.getTime() - 6 * 24 * 60 * 60 * 1000);
+            const lastMonth = new Date(now.getTime() - 25 * 24 * 60 * 60 * 1000);
+            const threeMonthsAgo = new Date(now.getTime() - 80 * 24 * 60 * 60 * 1000);
+            const sixMonthsAgo = new Date(now.getTime() - 180 * 24 * 60 * 60 * 1000);
+            it('should return 0.1 for documents modified within last week', () => {
+                expect(calculateRecencyBoost(yesterday)).toBe(0.1);
+                expect(calculateRecencyBoost(lastWeek)).toBe(0.1);
+            });
+            it('should return 0.05 for documents modified within last month', () => {
+                expect(calculateRecencyBoost(lastMonth)).toBe(0.05);
+            });
+            it('should return 0.02 for documents modified within last 3 months', () => {
+                expect(calculateRecencyBoost(threeMonthsAgo)).toBe(0.02);
+            });
+            it('should return 0.0 for older documents', () => {
+                expect(calculateRecencyBoost(sixMonthsAgo)).toBe(0.0);
+            });
+            it('should handle invalid dates gracefully', () => {
+                expect(calculateRecencyBoost(new Date('invalid'))).toBe(0.0);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(calculateRecencyBoost(null)).toBe(0.0);
+            });
+        });
+        describe('calculateTitleSimilarity', () => {
+            it('should return 0.3 for exact title match', () => {
+                const similarity = calculateTitleSimilarity('API Documentation', 'API Documentation');
+                expect(similarity).toBe(0.3);
+            });
+            it('should return score based on word overlap', () => {
+                const similarity = calculateTitleSimilarity('User Authentication API', 'Authentication Guide');
+                expect(similarity).toBeGreaterThan(0);
+                expect(similarity).toBeLessThanOrEqual(0.3);
+            });
+            it('should return 0 for completely different titles', () => {
+                const similarity = calculateTitleSimilarity('Frontend Guide', 'Backend Setup');
+                expect(similarity).toBe(0);
+            });
+            it('should handle edge cases gracefully', () => {
+                expect(calculateTitleSimilarity('', 'API')).toBe(0);
+                expect(calculateTitleSimilarity('API', '')).toBe(0);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(calculateTitleSimilarity(null, 'API')).toBe(0);
+            });
+            it('should filter out common stop words', () => {
+                // These titles share the word 'quick' which should be meaningful
+                const similarity = calculateTitleSimilarity('The Quick Guide', 'A Quick Reference');
+                expect(similarity).toBeGreaterThan(0); // 'quick' is meaningful
+                // Test with only stop words - should be 0
+                const stopWordsOnly = calculateTitleSimilarity('The Guide', 'A Reference');
+                expect(stopWordsOnly).toBe(0); // Only stop words, no meaningful overlap
+            });
+        });
+        describe('calculateLinkGraphBoost', () => {
+            const features = { enableLinkGraphBoost: true };
+            const disabledFeatures = { enableLinkGraphBoost: false };
+            it('should return 0.0 when feature is disabled', () => {
+                const boost = calculateLinkGraphBoost('See @/api/auth.md for details', '/api/auth.md', disabledFeatures);
+                expect(boost).toBe(0.0);
+            });
+            it('should return 0.3 when reference is found and feature enabled', () => {
+                const boost = calculateLinkGraphBoost('See @/api/auth.md for details', '/api/auth.md', features);
+                expect(boost).toBe(0.3);
+            });
+            it('should return 0.0 when no reference is found', () => {
+                const boost = calculateLinkGraphBoost('This content has no references', '/api/auth.md', features);
+                expect(boost).toBe(0.0);
+            });
+            it('should use default features when not provided', () => {
+                // Default features have linkGraphBoost disabled
+                const boost = calculateLinkGraphBoost('See @/api/auth.md for details', '/api/auth.md');
+                expect(boost).toBe(0.0);
+            });
+            it('should handle edge cases gracefully', () => {
+                expect(calculateLinkGraphBoost('', '/api/auth.md', features)).toBe(0.0);
+                expect(calculateLinkGraphBoost('content', '', features)).toBe(0.0);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(calculateLinkGraphBoost(null, '/api/auth.md', features)).toBe(0.0);
+            });
+        });
+        describe('Multi-factor calculateWeightedRelevance', () => {
+            const sourceKeywords = [
+                { keyword: 'api', weight: 3.0, sources: ['title'] },
+                { keyword: 'auth', weight: 5.0, sources: ['frontmatter'] }
+            ];
+            const baseParams = {
+                sourceTitle: 'User Authentication',
+                sourceNamespace: 'api/guides',
+                sourceContent: 'This covers auth @/api/specs/auth.md',
+                targetTitle: 'Authentication API',
+                targetContent: 'API for user authentication...',
+                targetNamespace: 'api/specs',
+                targetLastModified: new Date(),
+                targetPath: '/api/specs/auth.md'
+            };
+            it('should combine all relevance factors', () => {
+                const relevance = calculateWeightedRelevance(sourceKeywords, baseParams.sourceTitle, baseParams.sourceNamespace, baseParams.sourceContent, baseParams.targetTitle, baseParams.targetContent, baseParams.targetNamespace, baseParams.targetLastModified, baseParams.targetPath, undefined, { enableLinkGraphBoost: true });
+                expect(relevance).toBeGreaterThan(0);
+                expect(relevance).toBeLessThanOrEqual(1.0); // Should be capped at 1.0
+            });
+            it('should cap total relevance at 1.0', () => {
+                // Create scenario that would exceed 1.0 without capping
+                const highScoringKeywords = [
+                    { keyword: 'authentication', weight: 10.0, sources: ['title'] },
+                    { keyword: 'api', weight: 10.0, sources: ['frontmatter'] }
+                ];
+                const relevance = calculateWeightedRelevance(highScoringKeywords, 'Authentication API', // Same as target title for max title similarity
+                'api/specs', // Same namespace for max affinity
+                'Reference to @/api/specs/auth.md', 'Authentication API', 'authentication api implementation', 'api/specs', new Date(), // Recent for max recency boost
+                '/api/specs/auth.md', undefined, { enableLinkGraphBoost: true });
+                expect(relevance).toBe(1.0);
+            });
+            it('should handle missing optional parameters', () => {
+                const relevance = calculateWeightedRelevance(sourceKeywords, baseParams.sourceTitle, baseParams.sourceNamespace, baseParams.sourceContent, baseParams.targetTitle, baseParams.targetContent, baseParams.targetNamespace, baseParams.targetLastModified, baseParams.targetPath
+                // fingerprint and features omitted
+                );
+                expect(relevance).toBeGreaterThanOrEqual(0);
+                expect(relevance).toBeLessThanOrEqual(1.0);
+            });
+            it('should return 0 for empty source keywords', () => {
+                const relevance = calculateWeightedRelevance([], baseParams.sourceTitle, baseParams.sourceNamespace, baseParams.sourceContent, baseParams.targetTitle, baseParams.targetContent, baseParams.targetNamespace, baseParams.targetLastModified, baseParams.targetPath);
+                expect(relevance).toBe(0);
+            });
+            it('should provide debug information', () => {
+                // This test ensures that the function logs debug information
+                // We're not testing the exact log output, just that it doesn't throw
+                expect(() => {
+                    calculateWeightedRelevance(sourceKeywords, baseParams.sourceTitle, baseParams.sourceNamespace, baseParams.sourceContent, baseParams.targetTitle, baseParams.targetContent, baseParams.targetNamespace, baseParams.targetLastModified, baseParams.targetPath);
+                }).not.toThrow();
+            });
+            it('should demonstrate practical scoring example from improvement plan', () => {
+                // Example from the plan: Creating /api/guides/user-authentication.md
+                const sourceKeywords = [
+                    { keyword: 'user', weight: 3.0, sources: ['title'] },
+                    { keyword: 'auth', weight: 5.0, sources: ['frontmatter'] },
+                    { keyword: 'jwt', weight: 2.0, sources: ['content'] },
+                    { keyword: 'api', weight: 3.0, sources: ['title'] }
+                ];
+                // Document A: /api/specs/auth-api.md (high relevance expected)
+                const relevanceA = calculateWeightedRelevance(sourceKeywords, 'User Authentication Guide', // sourceTitle
+                'api/guides', // sourceNamespace
+                'User auth with JWT tokens', // sourceContent
+                'Auth API Specification', // targetTitle
+                'auth api implementation', // targetContent
+                'api/specs', // targetNamespace (related)
+                new Date(Date.now() - 24 * 60 * 60 * 1000), // yesterday (recent)
+                '/api/specs/auth-api.md', // targetPath
+                undefined, DEFAULT_SCORING_FEATURES);
+                expect(relevanceA).toBeGreaterThan(0.5); // Should be high relevance
+                expect(relevanceA).toBeLessThanOrEqual(1.0);
+                // Document B: /security/jwt-implementation.md (moderate relevance)
+                const relevanceB = calculateWeightedRelevance(sourceKeywords, 'User Authentication Guide', 'api/guides', 'Reference @/security/jwt-implementation.md', 'JWT Implementation', 'jwt implementation details', 'security', // Different namespace
+                new Date(Date.now() - 7 * 24 * 60 * 60 * 1000), // last week
+                '/security/jwt-implementation.md', undefined, { enableLinkGraphBoost: true } // Enable link boost for this test
+                );
+                expect(relevanceB).toBeGreaterThan(0.3); // Should have moderate relevance
+                expect(relevanceB).toBeLessThan(relevanceA); // Should be less than Document A
+            });
+        });
+    });
+    describe('factor-based explanation generation', () => {
+        describe('generateFactorBasedExplanation', () => {
+            it('should generate explanations for single factors', () => {
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.8, description: 'strong keyword overlap' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/specs');
+                expect(explanation).toBe('Strong keyword overlap in api/specs');
+            });
+            it('should generate explanations for two factors', () => {
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.7, description: 'good keyword overlap' },
+                    { factor: 'namespaceAffinity', score: 0.2, description: 'same namespace' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/specs');
+                expect(explanation).toBe('Good keyword overlap with same namespace');
+            });
+            it('should generate explanations for three factors', () => {
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.6, description: 'shared keywords' },
+                    { factor: 'titleSimilarity', score: 0.15, description: 'similar titles' },
+                    { factor: 'recencyBoost', score: 0.08, description: 'recently updated' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/guides');
+                expect(explanation).toBe('Shared keywords with similar titles and recently updated in api/guides');
+            });
+            it('should handle explicit keywords context', () => {
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.8, description: 'strong keyword overlap' },
+                    { factor: 'namespaceAffinity', score: 0.15, description: 'related namespace structure' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/specs', true);
+                expect(explanation).toBe('Strong explicit keyword matches with related namespace structure');
+            });
+            it('should handle namespace context already mentioned', () => {
+                const primaryFactors = [
+                    { factor: 'namespaceAffinity', score: 0.2, description: 'same namespace' },
+                    { factor: 'recencyBoost', score: 0.05, description: 'recent updates' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'frontend/components');
+                expect(explanation).toBe('Same namespace with recent updates');
+            });
+            it('should fallback gracefully for empty factors', () => {
+                const explanation = generateFactorBasedExplanation([], 'docs/troubleshooting');
+                expect(explanation).toBe('Related documentation in docs/troubleshooting');
+            });
+            it('should handle cross-referenced documentation', () => {
+                const primaryFactors = [
+                    { factor: 'linkGraphBoost', score: 0.3, description: 'cross-referenced documentation' },
+                    { factor: 'keywordOverlap', score: 0.4, description: 'shared keywords' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'backend/services');
+                expect(explanation).toBe('Cross-referenced documentation with shared keywords in backend/services');
+            });
+        });
+        describe('calculateWeightedRelevanceWithBreakdown', () => {
+            it('should return detailed factor breakdown', () => {
+                const sourceKeywords = [
+                    { keyword: 'api', weight: 3.0, sources: ['title'] },
+                    { keyword: 'auth', weight: 5.0, sources: ['frontmatter'] }
+                ];
+                const result = calculateWeightedRelevanceWithBreakdown(sourceKeywords, 'User Authentication API', 'api/guides', 'This covers authentication', 'Authentication API Reference', 'API for authentication and user management', 'api/specs', new Date(), '/api/specs/auth.md');
+                expect(result).toHaveProperty('relevance');
+                expect(result).toHaveProperty('factors');
+                expect(result).toHaveProperty('primaryFactors');
+                expect(result.factors).toHaveProperty('keywordOverlap');
+                expect(result.factors).toHaveProperty('titleSimilarity');
+                expect(result.factors).toHaveProperty('namespaceAffinity');
+                expect(result.factors).toHaveProperty('recencyBoost');
+                expect(result.factors).toHaveProperty('linkGraphBoost');
+                // Should have meaningful keyword overlap and title similarity
+                expect(result.factors.keywordOverlap).toBeGreaterThan(0.1);
+                expect(result.factors.titleSimilarity).toBeGreaterThan(0.1);
+                // Should identify primary factors
+                expect(result.primaryFactors.length).toBeGreaterThan(0);
+                expect(result.primaryFactors[0]).toHaveProperty('factor');
+                expect(result.primaryFactors[0]).toHaveProperty('score');
+                expect(result.primaryFactors[0]).toHaveProperty('description');
+            });
+            it('should handle empty keywords gracefully', () => {
+                const result = calculateWeightedRelevanceWithBreakdown([], 'Test Title', 'test/namespace', 'test content', 'Target Title', 'target content', 'target/namespace', new Date(), '/target/path.md');
+                expect(result.relevance).toBe(0);
+                expect(result.primaryFactors).toEqual([]);
+                expect(result.factors.keywordOverlap).toBe(0);
+            });
+            it('should identify same namespace factor', () => {
+                const sourceKeywords = [
+                    { keyword: 'test', weight: 1.0, sources: ['content'] }
+                ];
+                const result = calculateWeightedRelevanceWithBreakdown(sourceKeywords, 'Test Document', 'api/specs', 'test content', 'Another Test', 'more test content', 'api/specs', // Same namespace
+                new Date(), '/api/specs/another.md');
+                expect(result.factors.namespaceAffinity).toBe(0.2); // Exact namespace match
+                const namespaceFactors = result.primaryFactors.filter(f => f.factor === 'namespaceAffinity');
+                expect(namespaceFactors).toHaveLength(1);
+                expect(namespaceFactors[0]?.description).toBe('same namespace');
+            });
+            it('should identify related namespace factor', () => {
+                const sourceKeywords = [
+                    { keyword: 'test', weight: 1.0, sources: ['content'] }
+                ];
+                const result = calculateWeightedRelevanceWithBreakdown(sourceKeywords, 'Test Document', 'api/specs', 'test content', 'Another Test', 'more test content', 'api/guides', // Related namespace (same parent)
+                new Date(), '/api/guides/another.md');
+                expect(result.factors.namespaceAffinity).toBe(0.1); // Sibling namespace
+                const namespaceFactors = result.primaryFactors.filter(f => f.factor === 'namespaceAffinity');
+                if (namespaceFactors.length > 0) {
+                    expect(namespaceFactors[0]?.description).toBe('similar namespace');
+                }
+            });
+            it('should identify title similarity factor', () => {
+                const sourceKeywords = [
+                    { keyword: 'authentication', weight: 2.0, sources: ['title'] }
+                ];
+                const result = calculateWeightedRelevanceWithBreakdown(sourceKeywords, 'User Authentication Guide', 'guides', 'authentication content', 'Authentication API Reference', 'auth api content', 'api/specs', new Date(), '/api/specs/auth.md');
+                expect(result.factors.titleSimilarity).toBeGreaterThan(0.1);
+                const titleFactors = result.primaryFactors.filter(f => f.factor === 'titleSimilarity');
+                expect(titleFactors.length).toBeGreaterThan(0);
+                expect(titleFactors[0]?.description).toMatch(/similar titles|very similar titles/);
+            });
+            it('should identify recency boost factor', () => {
+                const sourceKeywords = [
+                    { keyword: 'test', weight: 1.0, sources: ['content'] }
+                ];
+                const recentDate = new Date(); // Very recent
+                const result = calculateWeightedRelevanceWithBreakdown(sourceKeywords, 'Test Document', 'test', 'test content', 'Target Document', 'test target content', 'test', recentDate, '/test/target.md');
+                expect(result.factors.recencyBoost).toBeGreaterThan(0.05);
+                const recencyFactors = result.primaryFactors.filter(f => f.factor === 'recencyBoost');
+                if (recencyFactors.length > 0) {
+                    expect(recencyFactors[0]?.description).toMatch(/recently updated|recent updates|updated recently/);
+                }
+            });
+        });
+        describe('explanation examples from improvement plan', () => {
+            it('should generate explanation matching improvement plan examples', () => {
+                // Example: Creating /api/guides/user-authentication.md with strong keyword overlap and same namespace
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.5, description: 'good keyword overlap' },
+                    { factor: 'namespaceAffinity', score: 0.2, description: 'related namespace structure' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/specs');
+                expect(explanation).toBe('Good keyword overlap with related namespace structure');
+            });
+            it('should handle cross-references with shared concepts', () => {
+                // Example: Documents with cross-references and shared technical concepts
+                const primaryFactors = [
+                    { factor: 'linkGraphBoost', score: 0.3, description: 'cross-referenced documentation' },
+                    { factor: 'keywordOverlap', score: 0.25, description: 'shared keywords' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'security');
+                expect(explanation).toBe('Cross-referenced documentation with shared keywords in security');
+            });
+            it('should handle explicit frontmatter keyword matches', () => {
+                // Test explicit keyword context replacement
+                const primaryFactors = [
+                    { factor: 'keywordOverlap', score: 0.8, description: 'strong keyword overlap' },
+                    { factor: 'titleSimilarity', score: 0.2, description: 'very similar titles' }
+                ];
+                const explanation = generateFactorBasedExplanation(primaryFactors, 'api/guides', true);
+                expect(explanation).toBe('Strong explicit keyword matches with very similar titles in api/guides');
+            });
+        });
+    });
+});
+//# sourceMappingURL=keyword-utils.test.js.map