@afterxleep/doc-bot 1.17.0 → 1.19.0

package/src/services/__tests__/DocumentationService.test.js

@@ -1,318 +0,0 @@
-import { DocumentationService } from '../DocumentationService.js';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-describe('DocumentationService', () => {
-  let docService;
-  let tempDocsPath;
-
-  beforeEach(async () => {
-    tempDocsPath = path.join(__dirname, 'temp-docs-' + Date.now());
-    await fs.ensureDir(tempDocsPath);
-    docService = new DocumentationService(tempDocsPath);
-  });
-
-  afterEach(async () => {
-    await fs.remove(tempDocsPath);
-  });
-
-  describe('extractRelevantSnippet', () => {
-    it('should extract snippet around exact phrase match', () => {
-      const content = `This is some content before the match.
-      Here we discuss how to use AlarmKit Framework effectively.
-      And this is content after the match.`;
-      
-      const snippet = docService.extractRelevantSnippet(
-        content,
-        ['use', 'alarmkit', 'framework'],
-        'use AlarmKit Framework'
-      );
-      
-      expect(snippet).toContain('use AlarmKit Framework');
-      expect(snippet.length).toBeLessThanOrEqual(250);
-    });
-
-    it('should find best snippet with most matching terms', () => {
-      const content = `# Introduction
-      This document covers various topics.
-      
-      # URLSession Configuration
-      Learn how to configure URLSession properly.
-      
-      # Advanced Usage
-      Here we discuss URLSession and configuration together.
-      URLSession provides many configuration options.`;
-      
-      const snippet = docService.extractRelevantSnippet(
-        content,
-        ['urlsession', 'configuration'],
-        'URLSession configuration'
-      );
-      
-      expect(snippet).toContain('URLSession');
-      expect(snippet).toContain('configuration');
-    });
-
-    it('should prioritize headers containing search terms', () => {
-      const content = `# Random Header
-      Some content here.
-      
-      # AlarmKit Integration
-      This is the section about integration.
-      
-      Some other content mentioning AlarmKit.`;
-      
-      const snippet = docService.extractRelevantSnippet(
-        content,
-        ['alarmkit', 'integration'],
-        'AlarmKit integration'
-      );
-      
-      expect(snippet).toContain('# AlarmKit Integration');
-    });
-
-    it('should return description from metadata if no good snippet found', () => {
-      const content = `---
-title: Test Document
-description: This is a comprehensive guide to using the API
----
-
-Some unrelated content here.`;
-      
-      const snippet = docService.extractRelevantSnippet(
-        content,
-        ['nonexistent', 'terms'],
-        'nonexistent terms'
-      );
-      
-      expect(snippet).toBe('This is a comprehensive guide to using the API');
-    });
-
-    it('should clean and format snippets properly', () => {
-      const content = `This is **bold** text with \`code\` and     multiple    spaces.`;
-      
-      const snippet = docService.extractRelevantSnippet(
-        content,
-        ['bold', 'text'],
-        'bold text'
-      );
-      
-      expect(snippet).not.toContain('**');
-      expect(snippet).not.toContain('`');
-      expect(snippet).not.toMatch(/\s{2,}/);
-    });
-  });
-
-  describe('getMatchedTerms', () => {
-    it('should return terms that match in document', () => {
-      const doc = {
-        content: 'Learn about URLSession and networking in Swift',
-        metadata: {
-          title: 'Swift Networking Guide',
-          description: 'A guide to URLSession'
-        },
-        fileName: 'networking.md'
-      };
-      
-      const matched = docService.getMatchedTerms(doc, ['urlsession', 'swift', 'api']);
-      
-      expect(matched).toContain('urlsession');
-      expect(matched).toContain('swift');
-      expect(matched).not.toContain('api');
-    });
-
-    it('should match terms in title and description', () => {
-      const doc = {
-        content: 'Some content',
-        metadata: {
-          title: 'AlarmKit Framework',
-          description: 'Learn to use AlarmKit'
-        },
-        fileName: 'guide.md'
-      };
-      
-      const matched = docService.getMatchedTerms(doc, ['alarmkit', 'framework', 'use']);
-      
-      expect(matched).toEqual(['alarmkit', 'framework', 'use']);
-    });
-  });
-
-  describe('searchDocuments with enhanced features', () => {
-    beforeEach(async () => {
-      // Create test documents
-      await fs.writeFile(
-        path.join(tempDocsPath, 'high-relevance.md'),
-        `---
-title: AlarmKit Framework Guide
-description: Complete guide to using AlarmKit Framework
-keywords: [alarmkit, framework, ios]
----
-
-# AlarmKit Framework
-
-Learn how to use AlarmKit Framework effectively.
-AlarmKit provides powerful alarm functionality.`
-      );
-
-      await fs.writeFile(
-        path.join(tempDocsPath, 'medium-relevance.md'),
-        `---
-title: iOS Development
-description: General iOS development guide
----
-
-# iOS Development
-
-This guide covers various frameworks including AlarmKit.`
-      );
-
-      await fs.writeFile(
-        path.join(tempDocsPath, 'low-relevance.md'),
-        `---
-title: Random Document
----
-
-# Random Content
-
-This has nothing to do with alarms or kits.`
-      );
-
-      await docService.initialize();
-    });
-
-    it('should return results with snippets and matched terms', async () => {
-      const results = await docService.searchDocuments('AlarmKit Framework');
-      
-      expect(results.length).toBeGreaterThan(0);
-      expect(results[0].snippet).toBeDefined();
-      expect(results[0].matchedTerms).toBeDefined();
-      expect(results[0].matchedTerms).toContain('alarmkit');
-      expect(results[0].matchedTerms).toContain('framework');
-    });
-
-    it('should filter out low relevance results', async () => {
-      const results = await docService.searchDocuments('AlarmKit Framework');
-      
-      // Should not include the "Random Document" with no relevant content
-      const hasLowRelevance = results.some(r => r.metadata?.title === 'Random Document');
-      expect(hasLowRelevance).toBe(false);
-    });
-
-    it('should prioritize exact phrase matches', async () => {
-      const results = await docService.searchDocuments('AlarmKit Framework');
-      
-      expect(results[0].metadata?.title).toBe('AlarmKit Framework Guide');
-      expect(results[0].relevanceScore).toBeGreaterThan(50);
-    });
-
-    it('should boost keyword matches', async () => {
-      const results = await docService.searchDocuments('alarmkit');
-      
-      // Document with alarmkit in keywords should score higher
-      expect(results[0].metadata?.keywords).toContain('alarmkit');
-    });
-  });
-
-  describe('calculateAdvancedRelevanceScore', () => {
-    it('should give high score for exact phrase match', () => {
-      const doc = {
-        content: 'Learn how to use AlarmKit Framework in your iOS app',
-        metadata: { title: 'iOS Guide' },
-        fileName: 'guide.md'
-      };
-      
-      const score = docService.calculateAdvancedRelevanceScore(
-        doc,
-        ['alarmkit', 'framework'],
-        'AlarmKit Framework'
-      );
-      
-      expect(score).toBeGreaterThan(20); // Exact phrase bonus
-    });
-
-    it('should boost matches in title', () => {
-      const doc1 = {
-        content: 'Some content about URLSession',
-        metadata: { title: 'URLSession Guide' },
-        fileName: 'guide1.md'
-      };
-      
-      const doc2 = {
-        content: 'URLSession is mentioned here',
-        metadata: { title: 'Random Guide' },
-        fileName: 'guide2.md'
-      };
-      
-      const score1 = docService.calculateAdvancedRelevanceScore(
-        doc1,
-        ['urlsession'],
-        'URLSession'
-      );
-      
-      const score2 = docService.calculateAdvancedRelevanceScore(
-        doc2,
-        ['urlsession'],
-        'URLSession'
-      );
-      
-      expect(score1).toBeGreaterThan(score2);
-    });
-
-    it('should apply term coverage bonus', () => {
-      const doc = {
-        content: 'URLSession configuration and usage',
-        metadata: { title: 'Networking' },
-        fileName: 'net.md'
-      };
-      
-      const score1 = docService.calculateAdvancedRelevanceScore(
-        doc,
-        ['urlsession'],
-        'URLSession'
-      );
-      
-      const score2 = docService.calculateAdvancedRelevanceScore(
-        doc,
-        ['urlsession', 'configuration'],
-        'URLSession configuration'
-      );
-      
-      // Matching both terms should score higher
-      expect(score2).toBeGreaterThan(score1);
-    });
-
-    it('should cap content match frequency to prevent spam', () => {
-      const spamDoc = {
-        content: 'test '.repeat(100),
-        metadata: { title: 'Spam' },
-        fileName: 'spam.md'
-      };
-      
-      const normalDoc = {
-        content: 'This is a test document with normal content',
-        metadata: { title: 'Normal' },
-        fileName: 'normal.md'
-      };
-      
-      const spamScore = docService.calculateAdvancedRelevanceScore(
-        spamDoc,
-        ['test'],
-        'test'
-      );
-      
-      const normalScore = docService.calculateAdvancedRelevanceScore(
-        normalDoc,
-        ['test'],
-        'test'
-      );
-      
-      // Spam score should be capped, not drastically higher
-      expect(spamScore / normalScore).toBeLessThan(5);
-    });
-  });
-});

package/src/services/__tests__/UnifiedSearchService.test.js

@@ -1,302 +0,0 @@
-import { UnifiedSearchService } from '../UnifiedSearchService.js';
-import { DocumentationService } from '../DocumentationService.js';
-import { MultiDocsetDatabase } from '../docset/database.js';
-import { jest } from '@jest/globals';
-
-describe('UnifiedSearchService', () => {
-  let unifiedSearchService;
-  let mockDocumentationService;
-  let mockMultiDocsetDatabase;
-
-  beforeEach(() => {
-    // Mock DocumentationService
-    mockDocumentationService = {
-      searchDocuments: jest.fn().mockResolvedValue([]),
-      documents: new Map()
-    };
-
-    // Mock MultiDocsetDatabase
-    mockMultiDocsetDatabase = {
-      searchWithTerms: jest.fn().mockReturnValue([]),
-      databases: new Map(),
-      getStats: jest.fn().mockReturnValue([])
-    };
-
-    unifiedSearchService = new UnifiedSearchService(
-      mockDocumentationService,
-      mockMultiDocsetDatabase
-    );
-  });
-
-  describe('parseQuery', () => {
-    it('should parse query into terms removing stop words', () => {
-      const terms = unifiedSearchService.parseQuery('How to use AlarmKit Framework');
-      expect(terms).toEqual(['use', 'alarmkit', 'framework']);
-    });
-
-    it('should handle queries with special characters', () => {
-      const terms = unifiedSearchService.parseQuery('URLSession.shared configuration!');
-      expect(terms).toEqual(['urlsessionshared', 'configuration']);
-    });
-
-    it('should filter out short terms', () => {
-      const terms = unifiedSearchService.parseQuery('a I URLSession x');
-      expect(terms).toEqual(['urlsession']);
-    });
-
-    it('should preserve dots, dashes and underscores', () => {
-      const terms = unifiedSearchService.parseQuery('URLSession.shared my-function test_var');
-      expect(terms).toEqual(['urlsession.shared', 'my-function', 'test_var']);
-    });
-
-    it('should handle empty query', () => {
-      const terms = unifiedSearchService.parseQuery('');
-      expect(terms).toEqual([]);
-    });
-  });
-
-  describe('search', () => {
-    it('should return empty array for empty query', async () => {
-      const results = await unifiedSearchService.search('');
-      expect(results).toEqual([]);
-    });
-
-    it('should return empty array for query with only stop words', async () => {
-      const results = await unifiedSearchService.search('the is are was');
-      expect(results).toEqual([]);
-    });
-
-    it('should search both local and docset documentation', async () => {
-      const localResults = [
-        {
-          fileName: 'test.md',
-          content: 'Test content',
-          metadata: { title: 'Test' },
-          relevanceScore: 50
-        }
-      ];
-
-      const docsetResults = [
-        {
-          name: 'TestClass',
-          type: 'Class',
-          path: 'test.html',
-          docsetId: 'mock',
-          docsetName: 'Mock',
-          relevanceScore: 40
-        }
-      ];
-
-      mockDocumentationService.searchDocuments.mockResolvedValue(localResults);
-      mockMultiDocsetDatabase.searchWithTerms.mockReturnValue(docsetResults);
-
-      const results = await unifiedSearchService.search('test');
-      
-      expect(mockDocumentationService.searchDocuments).toHaveBeenCalledWith('test');
-      expect(mockMultiDocsetDatabase.searchWithTerms).toHaveBeenCalledWith(
-        ['test'],
-        { type: undefined, docsetId: undefined, limit: 10 }
-      );
-      
-      expect(results).toHaveLength(2);
-      // Local result should be boosted and come first
-      expect(results[0].type).toBe('local');
-      expect(results[0].relevanceScore).toBe(250); // 50 * 5
-      expect(results[1].type).toBe('docset');
-    });
-
-    it('should not search local docs when docsetId is specified', async () => {
-      mockMultiDocsetDatabase.searchWithTerms.mockReturnValue([]);
-      
-      await unifiedSearchService.search('test', { docsetId: 'specific-docset' });
-      
-      expect(mockDocumentationService.searchDocuments).not.toHaveBeenCalled();
-      expect(mockMultiDocsetDatabase.searchWithTerms).toHaveBeenCalledWith(
-        ['test'],
-        { type: undefined, docsetId: 'specific-docset', limit: 10 }
-      );
-    });
-
-    it('should apply quality filtering when high-quality results exist', async () => {
-      const mixedResults = [
-        {
-          fileName: 'high-quality.md',
-          content: 'Highly relevant',
-          metadata: { title: 'Perfect Match' },
-          relevanceScore: 80
-        },
-        {
-          fileName: 'medium.md',
-          content: 'Somewhat relevant',
-          metadata: { title: 'Partial Match' },
-          relevanceScore: 30
-        },
-        {
-          fileName: 'low.md',
-          content: 'Barely relevant',
-          metadata: { title: 'Weak Match' },
-          relevanceScore: 5
-        }
-      ];
-
-      mockDocumentationService.searchDocuments.mockResolvedValue(mixedResults);
-      
-      const results = await unifiedSearchService.search('test', { limit: 10 });
-      
-      // Should only include high-quality results (score >= 50 after boosting)
-      expect(results.length).toBe(2);
-      expect(results[0].relevanceScore).toBe(400); // 80 * 5
-      expect(results[1].relevanceScore).toBe(150); // 30 * 5
-    });
-
-    it('should handle search errors gracefully', async () => {
-      mockDocumentationService.searchDocuments.mockRejectedValue(new Error('Search failed'));
-      mockMultiDocsetDatabase.searchWithTerms.mockImplementation(() => {
-        throw new Error('Database error');
-      });
-
-      const results = await unifiedSearchService.search('test');
-      expect(results).toEqual([]);
-    });
-  });
-
-  describe('normalizeLocalResults', () => {
-    it('should normalize local documentation results', () => {
-      const localResults = [
-        {
-          fileName: 'guide.md',
-          content: 'Full content here',
-          metadata: { 
-            title: 'User Guide',
-            description: 'A comprehensive guide'
-          },
-          relevanceScore: 75,
-          snippet: 'This is a snippet...',
-          matchedTerms: ['guide', 'user']
-        }
-      ];
-
-      const normalized = unifiedSearchService.normalizeLocalResults(localResults);
-      
-      expect(normalized[0]).toEqual({
-        id: 'guide.md',
-        title: 'User Guide',
-        description: 'A comprehensive guide',
-        type: 'local',
-        source: 'project',
-        path: 'guide.md',
-        url: 'guide.md',
-        relevanceScore: 75,
-        metadata: localResults[0].metadata,
-        content: 'Full content here',
-        snippet: 'This is a snippet...',
-        matchedTerms: ['guide', 'user']
-      });
-    });
-
-    it('should handle missing metadata gracefully', () => {
-      const localResults = [
-        {
-          fileName: 'readme.md',
-          content: 'Content',
-          relevanceScore: 50
-        }
-      ];
-
-      const normalized = unifiedSearchService.normalizeLocalResults(localResults);
-      
-      expect(normalized[0].title).toBe('readme.md');
-      expect(normalized[0].description).toBe('');
-      expect(normalized[0].matchedTerms).toEqual([]);
-    });
-  });
-
-  describe('normalizeDocsetResults', () => {
-    it('should normalize and deduplicate docset results', () => {
-      const docsetResults = [
-        {
-          name: 'URLSession',
-          type: 'Class',
-          path: 'path1.html',
-          url: 'https://example.com/path1.html',
-          docsetId: 'apple',
-          docsetName: 'Apple',
-          relevanceScore: 60
-        },
-        {
-          name: 'URLSession',
-          type: 'Class',
-          path: 'path2.html?language=swift',
-          url: 'https://example.com/path2.html?language=swift',
-          docsetId: 'apple',
-          docsetName: 'Apple',
-          relevanceScore: 50
-        }
-      ];
-
-      const normalized = unifiedSearchService.normalizeDocsetResults(docsetResults);
-      
-      // Should deduplicate and prefer Swift entry
-      expect(normalized).toHaveLength(1);
-      expect(normalized[0].url).toContain('language=swift');
-    });
-
-    it('should keep higher score when neither is Swift', () => {
-      const docsetResults = [
-        {
-          name: 'TestClass',
-          type: 'Class',
-          path: 'path1.html',
-          url: 'https://example.com/path1.html',
-          docsetId: 'mock',
-          docsetName: 'Mock',
-          relevanceScore: 70
-        },
-        {
-          name: 'TestClass',
-          type: 'Class',
-          path: 'path2.html',
-          url: 'https://example.com/path2.html',
-          docsetId: 'mock',
-          docsetName: 'Mock',
-          relevanceScore: 80
-        }
-      ];
-
-      const normalized = unifiedSearchService.normalizeDocsetResults(docsetResults);
-      
-      expect(normalized).toHaveLength(1);
-      expect(normalized[0].relevanceScore).toBe(80);
-    });
-  });
-
-  describe('getSources', () => {
-    it('should return summary of available documentation sources', async () => {
-      mockDocumentationService.documents.set('doc1.md', {});
-      mockDocumentationService.documents.set('doc2.md', {});
-      
-      mockMultiDocsetDatabase.databases.set('apple', {});
-      mockMultiDocsetDatabase.databases.set('mock', {});
-      mockMultiDocsetDatabase.getStats.mockReturnValue([
-        { docsetId: 'apple', docsetName: 'Apple', entryCount: 1000 },
-        { docsetId: 'mock', docsetName: 'Mock', entryCount: 50 }
-      ]);
-
-      const sources = await unifiedSearchService.getSources();
-      
-      expect(sources).toEqual({
-        local: {
-          documentCount: 2,
-          indexed: true
-        },
-        docsets: {
-          count: 2,
-          details: [
-            { docsetId: 'apple', docsetName: 'Apple', entryCount: 1000 },
-            { docsetId: 'mock', docsetName: 'Mock', entryCount: 50 }
-          ]
-        }
-      });
-    });
-  });
-});