@amirdaraee/namewise 0.5.3 → 0.5.4

package/tests/unit/services/openai-service.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { OpenAIService } from '../../../src/services/openai-service.js';
-
-// Mock the OpenAI SDK
-vi.mock('openai', () => {
-  const MockOpenAI = vi.fn().mockImplementation(() => ({
-    chat: {
-      completions: {
-        create: vi.fn()
-      }
-    }
-  }));
-  return {
-    default: MockOpenAI
-  };
-});
-
-describe('OpenAIService', () => {
-  let service: OpenAIService;
-  let mockClient: any;
-
-  beforeEach(() => {
-    service = new OpenAIService('test-api-key');
-    mockClient = (service as any).client;
-  });
-
-  describe('Basic Properties', () => {
-    it('should have correct name', () => {
-      expect(service.name).toBe('OpenAI');
-    });
-
-    it('should initialize with API key', () => {
-      expect(service).toBeDefined();
-    });
-  });
-
-  describe('generateFileName() with different naming conventions', () => {
-    const sampleContent = 'This is a user manual for software installation and configuration.';
-    const originalName = 'manual.docx';
-
-    beforeEach(() => {
-      mockClient.chat.completions.create.mockResolvedValue({
-        choices: [
-          {
-            message: {
-              content: 'user manual software installation configuration'
-            }
-          }
-        ]
-      });
-    });
-
-    it('should generate filename with kebab-case convention (default)', async () => {
-      const result = await service.generateFileName(sampleContent, originalName);
-      
-      expect(mockClient.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          model: 'gpt-3.5-turbo',
-          messages: [expect.objectContaining({
-            role: 'user',
-            content: expect.stringContaining('Use lowercase with hyphens between words')
-          })],
-          temperature: 0.3
-        })
-      );
-      
-      expect(result).toBe('user-manual-software-installation-configuration');
-    });
-
-    it('should generate filename with snake_case convention', async () => {
-      const result = await service.generateFileName(sampleContent, originalName, 'snake_case');
-      
-      expect(mockClient.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          messages: [expect.objectContaining({
-            content: expect.stringContaining('Use lowercase with underscores between words')
-          })]
-        })
-      );
-      
-      expect(result).toBe('user_manual_software_installation_configuration');
-    });
-
-    it('should generate filename with camelCase convention', async () => {
-      const result = await service.generateFileName(sampleContent, originalName, 'camelCase');
-      
-      expect(mockClient.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          messages: [expect.objectContaining({
-            content: expect.stringContaining('Use camelCase format starting with lowercase')
-          })]
-        })
-      );
-      
-      expect(result).toBe('userManualSoftwareInstallationConfiguration');
-    });
-
-    it('should generate filename with UPPERCASE convention', async () => {
-      const result = await service.generateFileName(sampleContent, originalName, 'UPPERCASE');
-      
-      expect(result).toBe('USERMANUALSOFTWAREINSTALLATIONCONFIGURATION');
-    });
-
-    it('should include original filename and content in prompt', async () => {
-      await service.generateFileName(sampleContent, originalName, 'kebab-case');
-      
-      const call = mockClient.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain(sampleContent.substring(0, 2000));
-      expect(call.messages[0].content).toContain('Document content (first 2000 characters)');
-    });
-
-    it('should use correct OpenAI parameters', async () => {
-      await service.generateFileName(sampleContent, originalName);
-      
-      expect(mockClient.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          model: 'gpt-3.5-turbo',
-          max_tokens: 100,
-          temperature: 0.3
-        })
-      );
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle API errors gracefully', async () => {
-      mockClient.chat.completions.create.mockRejectedValue(new Error('OpenAI API Error'));
-      
-      await expect(service.generateFileName('content', 'file.txt')).rejects.toThrow(
-        'Failed to generate filename with OpenAI: OpenAI API Error'
-      );
-    });
-
-    it('should handle empty choices response', async () => {
-      mockClient.chat.completions.create.mockResolvedValue({
-        choices: []
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt');
-      expect(result).toBe('untitled-document');
-    });
-
-    it('should handle missing message content', async () => {
-      mockClient.chat.completions.create.mockResolvedValue({
-        choices: [
-          {
-            message: {
-              content: null
-            }
-          }
-        ]
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt');
-      expect(result).toBe('untitled-document');
-    });
-
-    it('should handle undefined choices', async () => {
-      mockClient.chat.completions.create.mockResolvedValue({
-        choices: [undefined]
-      });
-      
-      const result = await service.generateFileName('content', 'file.txt');
-      expect(result).toBe('untitled-document');
-    });
-  });
-
-  describe('Filename Sanitization', () => {
-    beforeEach(() => {
-      mockClient.chat.completions.create.mockResolvedValue({
-        choices: [
-          {
-            message: {
-              content: 'Test@Document#With$Special%Characters.xlsx'
-            }
-          }
-        ]
-      });
-    });
-
-    it('should sanitize special characters and apply naming convention', async () => {
-      const result = await service.generateFileName('content', 'original.txt', 'kebab-case');
-      expect(result).toBe('testdocumentwithspecialcharacters');
-    });
-
-    it('should handle different conventions for sanitized input', async () => {
-      const kebabResult = await service.generateFileName('content', 'file.txt', 'kebab-case');
-      const snakeResult = await service.generateFileName('content', 'file.txt', 'snake_case');
-      const camelResult = await service.generateFileName('content', 'file.txt', 'camelCase');
-      
-      expect(kebabResult).toBe('testdocumentwithspecialcharacters');
-      expect(snakeResult).toBe('testdocumentwithspecialcharacters');
-      expect(camelResult).toBe('testdocumentwithspecialcharacters');
-    });
-  });
-});

package/tests/unit/utils/ai-prompts.test.ts

@@ -1,213 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildFileNamePrompt, AI_SYSTEM_PROMPT } from '../../../src/utils/ai-prompts.js';
-import { FileInfo } from '../../../src/types/index.js';
-
-describe('AI Prompts', () => {
-  describe('buildFileNamePrompt', () => {
-    it('should build basic prompt with minimal context', () => {
-      const prompt = buildFileNamePrompt({
-        content: 'This is a sample document about contract negotiations.',
-        originalName: 'document.pdf',
-        namingConvention: 'kebab-case',
-        category: 'general'
-      });
-
-      expect(prompt).toContain('Based on the following document information');
-      expect(prompt).toContain('Descriptive and meaningful');
-      expect(prompt).toContain('Between 3-10 words');
-      expect(prompt).toContain('hyphens between words');
-      expect(prompt).toContain('This is a sample document about contract negotiations');
-      expect(prompt).toContain('Respond with only the filename');
-    });
-
-    it('should include file metadata when provided', () => {
-      const mockFileInfo: FileInfo = {
-        name: 'contract.pdf',
-        path: '/documents/contract.pdf',
-        extension: '.pdf',
-        size: 1024 * 50, // 50KB
-        createdAt: new Date('2024-01-15'),
-        modifiedAt: new Date('2024-02-01'),
-        parentFolder: 'contracts',
-        folderPath: ['home', 'documents', 'contracts']
-      };
-
-      const prompt = buildFileNamePrompt({
-        content: 'Employment contract for John Doe.',
-        originalName: 'contract.pdf',
-        namingConvention: 'kebab-case',
-        category: 'document',
-        fileInfo: mockFileInfo
-      });
-
-      expect(prompt).toContain('File Information:');
-      expect(prompt).toContain('- Original filename: contract.pdf');
-      expect(prompt).toContain('- File size: 50KB');
-      expect(prompt).toContain('- Parent folder: contracts');
-      expect(prompt).toContain('- Folder path: home > documents > contracts');
-    });
-
-    it('should include document metadata when available', () => {
-      const mockFileInfo: FileInfo = {
-        name: 'report.pdf',
-        path: '/reports/report.pdf',
-        extension: '.pdf',
-        size: 1024 * 100,
-        createdAt: new Date('2024-01-15'),
-        modifiedAt: new Date('2024-02-01'),
-        parentFolder: 'reports',
-        folderPath: ['home', 'reports'],
-        documentMetadata: {
-          title: 'Annual Financial Report',
-          author: 'Jane Smith',
-          creator: 'Microsoft Word',
-          subject: 'Company Finances',
-          keywords: ['finance', 'annual', 'report'],
-          creationDate: new Date('2024-01-10'),
-          modificationDate: new Date('2024-01-20'),
-          pages: 25,
-          wordCount: 5000
-        }
-      };
-
-      const prompt = buildFileNamePrompt({
-        content: 'This report covers the annual financial performance...',
-        originalName: 'report.pdf',
-        namingConvention: 'snake_case',
-        category: 'document',
-        fileInfo: mockFileInfo
-      });
-
-      expect(prompt).toContain('Document Properties:');
-      expect(prompt).toContain('- Title: Annual Financial Report');
-      expect(prompt).toContain('- Author: Jane Smith');
-      expect(prompt).toContain('- Creator: Microsoft Word');
-      expect(prompt).toContain('- Subject: Company Finances');
-      expect(prompt).toContain('- Keywords: finance, annual, report');
-      expect(prompt).toContain('- Pages: 25');
-      expect(prompt).toContain('- Word count: 5000');
-    });
-
-    it('should include person name detection instructions', () => {
-      const prompt = buildFileNamePrompt({
-        content: 'Visa application for Setareh Ahmadi to visit Canada.',
-        originalName: 'visa-app.pdf',
-        namingConvention: 'kebab-case',
-        category: 'document'
-      });
-
-      expect(prompt).toContain('If the document is specifically for/about a person (based on content), include their name at the beginning');
-      expect(prompt).toContain('Important: If this document is specifically for or about a particular person mentioned in the content, start the filename with their name');
-    });
-
-    it('should include folder name filtering instructions', () => {
-      const prompt = buildFileNamePrompt({
-        content: 'Meeting notes from Q4 planning session.',
-        originalName: 'notes.txt',
-        namingConvention: 'camelCase',
-        category: 'general'
-      });
-
-      expect(prompt).toContain('Ignore irrelevant folder names that don\'t describe the document content');
-      expect(prompt).toContain('Focus on the document\'s actual content and purpose, not just metadata');
-    });
-
-    it('should handle different naming conventions', () => {
-      const kebabPrompt = buildFileNamePrompt({
-        content: 'Test content',
-        originalName: 'test.txt',
-        namingConvention: 'kebab-case',
-        category: 'general'
-      });
-
-      const snakePrompt = buildFileNamePrompt({
-        content: 'Test content',
-        originalName: 'test.txt',
-        namingConvention: 'snake_case',
-        category: 'general'
-      });
-
-      expect(kebabPrompt).toContain('hyphens between words');
-      expect(snakePrompt).toContain('underscores between words');
-    });
-
-    it('should handle different file categories', () => {
-      const documentPrompt = buildFileNamePrompt({
-        content: 'Contract content',
-        originalName: 'contract.pdf',
-        namingConvention: 'kebab-case',
-        category: 'document'
-      });
-
-      const moviePrompt = buildFileNamePrompt({
-        content: 'Movie file content',
-        originalName: 'movie.mp4',
-        namingConvention: 'kebab-case',
-        category: 'movie'
-      });
-
-      expect(documentPrompt).toContain('document');
-      expect(moviePrompt).toContain('movie');
-    });
-
-    it('should truncate content to 2000 characters', () => {
-      const longContent = 'a'.repeat(3000);
-      
-      const prompt = buildFileNamePrompt({
-        content: longContent,
-        originalName: 'long.txt',
-        namingConvention: 'kebab-case',
-        category: 'general'
-      });
-
-      const contentSection = prompt.substring(prompt.indexOf('Document content'));
-      expect(contentSection).toContain('a'.repeat(2000));
-      expect(contentSection).not.toContain('a'.repeat(2001));
-    });
-
-    it('should handle missing optional metadata gracefully', () => {
-      const mockFileInfo: FileInfo = {
-        name: 'simple.txt',
-        path: '/simple.txt',
-        extension: '.txt',
-        size: 1024,
-        createdAt: new Date('2024-01-15'),
-        modifiedAt: new Date('2024-02-01'),
-        parentFolder: 'root',
-        folderPath: ['root'],
-        documentMetadata: {
-          // Only some fields provided
-          title: 'Simple Document'
-          // author, creator, etc. are undefined
-        }
-      };
-
-      const prompt = buildFileNamePrompt({
-        content: 'Simple document content.',
-        originalName: 'simple.txt',
-        namingConvention: 'kebab-case',
-        category: 'general',
-        fileInfo: mockFileInfo
-      });
-
-      expect(prompt).toContain('- Title: Simple Document');
-      expect(prompt).not.toContain('- Author:');
-      expect(prompt).not.toContain('- Creator:');
-    });
-  });
-
-  describe('AI_SYSTEM_PROMPT', () => {
-    it('should provide clear system instructions', () => {
-      expect(AI_SYSTEM_PROMPT).toContain('helpful assistant');
-      expect(AI_SYSTEM_PROMPT).toContain('generates descriptive filenames');
-      expect(AI_SYSTEM_PROMPT).toContain('just the filename');
-      expect(AI_SYSTEM_PROMPT).toContain('no explanation');
-    });
-
-    it('should be a non-empty string', () => {
-      expect(AI_SYSTEM_PROMPT).toBeTruthy();
-      expect(typeof AI_SYSTEM_PROMPT).toBe('string');
-      expect(AI_SYSTEM_PROMPT.length).toBeGreaterThan(20);
-    });
-  });
-});

package/tests/unit/utils/file-templates.test.ts

@@ -1,199 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { 
-  categorizeFile, 
-  applyTemplate, 
-  getTemplateInstructions, 
-  FILE_TEMPLATES,
-  FileCategory 
-} from '../../../src/utils/file-templates.js';
-
-describe('File Templates', () => {
-  describe('categorizeFile()', () => {
-    it('should categorize document files', () => {
-      expect(categorizeFile('/path/contract.pdf')).toBe('document');
-      expect(categorizeFile('/path/license.docx')).toBe('document');
-      expect(categorizeFile('/path/certificate.txt')).toBe('document');
-    });
-
-    it('should categorize document files by content', () => {
-      expect(categorizeFile('/path/file.pdf', 'This is a work contract agreement')).toBe('document');
-      expect(categorizeFile('/path/file.pdf', 'License application form')).toBe('document');
-      expect(categorizeFile('/path/file.pdf', 'Invoice for services rendered')).toBe('document');
-    });
-
-    it('should categorize movie files', () => {
-      expect(categorizeFile('/path/movie.mp4')).toBe('movie');
-      expect(categorizeFile('/path/film.mkv')).toBe('movie');
-      expect(categorizeFile('/path/video.avi')).toBe('movie');
-    });
-
-    it('should categorize series files', () => {
-      expect(categorizeFile('/path/show.s01e01.mkv')).toBe('series');
-      expect(categorizeFile('/path/series.season.1.mp4')).toBe('series');
-      expect(categorizeFile('/path/tv.episode.avi')).toBe('series');
-    });
-
-    it('should categorize music files', () => {
-      expect(categorizeFile('/path/song.mp3')).toBe('music');
-      expect(categorizeFile('/path/audio.flac')).toBe('music');
-      expect(categorizeFile('/path/track.wav')).toBe('music');
-    });
-
-    it('should categorize photo files', () => {
-      expect(categorizeFile('/path/image.jpg')).toBe('photo');
-      expect(categorizeFile('/path/picture.png')).toBe('photo');
-      expect(categorizeFile('/path/photo.heic')).toBe('photo');
-    });
-
-    it('should categorize book files', () => {
-      expect(categorizeFile('/path/novel.epub')).toBe('book');
-      expect(categorizeFile('/path/book.mobi')).toBe('book');
-      expect(categorizeFile('/path/ebook.azw')).toBe('book');
-    });
-
-    it('should default to general for unknown types', () => {
-      expect(categorizeFile('/path/unknown.xyz')).toBe('general');
-      expect(categorizeFile('/path/file')).toBe('general');
-    });
-
-    it('should prioritize series over movie for video files with series keywords', () => {
-      expect(categorizeFile('/path/breaking-bad.s01e01.mp4')).toBe('series');
-      expect(categorizeFile('/path/movie.mkv', 'This is season 1 episode 1')).toBe('series');
-    });
-  });
-
-  describe('applyTemplate()', () => {
-    it('should apply document template with personal name and date', () => {
-      const result = applyTemplate(
-        'driving-license',
-        'document',
-        { category: 'document', personalName: 'amirhossein', dateFormat: 'YYYYMMDD' },
-        'kebab-case'
-      );
-      
-      // Should match pattern: {content}-{personalName}-{date}
-      expect(result).toMatch(/^driving-license-amirhossein-\d{8}$/);
-    });
-
-    it('should apply movie template with year', () => {
-      const result = applyTemplate(
-        'the-dark-knight',
-        'movie',
-        { category: 'movie', dateFormat: 'YYYY' },
-        'kebab-case'
-      );
-      
-      // Movies don't use personal names in their template pattern
-      expect(result).toBe('the-dark-knight');
-    });
-
-    it('should apply different date formats', () => {
-      const baseOptions = { category: 'document' as FileCategory, personalName: 'john' };
-      
-      const yyyymmdd = applyTemplate('contract', 'document', { ...baseOptions, dateFormat: 'YYYYMMDD' }, 'kebab-case');
-      const yyyymmdd2 = applyTemplate('contract', 'document', { ...baseOptions, dateFormat: 'YYYY-MM-DD' }, 'kebab-case');
-      const yyyy = applyTemplate('contract', 'document', { ...baseOptions, dateFormat: 'YYYY' }, 'kebab-case');
-      
-      expect(yyyymmdd).toMatch(/^contract-john-\d{8}$/);
-      expect(yyyymmdd2).toMatch(/^contract-john-\d{4}-\d{2}-\d{2}$/);
-      expect(yyyy).toMatch(/^contract-john-\d{4}$/);
-    });
-
-    it('should handle no date format', () => {
-      const result = applyTemplate(
-        'document',
-        'document',
-        { category: 'document', personalName: 'jane', dateFormat: 'none' },
-        'kebab-case'
-      );
-      
-      expect(result).toBe('document-jane');
-    });
-
-    it('should handle missing personal name', () => {
-      const result = applyTemplate(
-        'report',
-        'document',
-        { category: 'document', dateFormat: 'YYYY' },
-        'kebab-case'
-      );
-      
-      expect(result).toMatch(/^report-\d{4}$/);
-    });
-
-    it('should apply naming conventions correctly', () => {
-      const baseOptions = { category: 'document' as FileCategory, personalName: 'test-user', dateFormat: 'none' as const };
-      
-      const kebab = applyTemplate('My Document', 'document', baseOptions, 'kebab-case');
-      const snake = applyTemplate('My Document', 'document', baseOptions, 'snake_case');
-      const camel = applyTemplate('My Document', 'document', baseOptions, 'camelCase');
-      
-      expect(kebab).toBe('my-document-test-user');
-      expect(snake).toBe('my_document_test_user');
-      expect(camel).toBe('myDocumentTestUser');
-    });
-
-    it('should clean up multiple separators', () => {
-      const result = applyTemplate(
-        'test--document',
-        'document',
-        { category: 'document', personalName: 'user', dateFormat: 'none' },
-        'kebab-case'
-      );
-      
-      expect(result).toBe('test-document-user');
-    });
-
-    it('should handle general category', () => {
-      const result = applyTemplate(
-        'meeting-notes',
-        'general',
-        { category: 'general', personalName: 'admin', dateFormat: 'YYYY' },
-        'kebab-case'
-      );
-      
-      expect(result).toBe('meeting-notes');
-    });
-  });
-
-  describe('getTemplateInstructions()', () => {
-    it('should return instructions for each category', () => {
-      const categories: FileCategory[] = ['document', 'movie', 'music', 'series', 'photo', 'book', 'general'];
-      
-      categories.forEach(category => {
-        const instructions = getTemplateInstructions(category);
-        expect(instructions).toContain(category);
-        expect(instructions.length).toBeGreaterThan(10);
-      });
-    });
-
-    it('should include examples in instructions', () => {
-      const documentInstructions = getTemplateInstructions('document');
-      expect(documentInstructions).toContain('driving-license-amirhossein');
-      
-      const movieInstructions = getTemplateInstructions('movie');
-      expect(movieInstructions).toContain('the-dark-knight-2008');
-    });
-  });
-
-  describe('FILE_TEMPLATES', () => {
-    it('should have all required template categories', () => {
-      const expectedCategories: FileCategory[] = ['document', 'movie', 'music', 'series', 'photo', 'book', 'general'];
-      
-      expectedCategories.forEach(category => {
-        expect(FILE_TEMPLATES[category]).toBeDefined();
-        expect(FILE_TEMPLATES[category].category).toBe(category);
-        expect(FILE_TEMPLATES[category].pattern).toBeDefined();
-        expect(FILE_TEMPLATES[category].description).toBeDefined();
-        expect(FILE_TEMPLATES[category].examples.length).toBeGreaterThan(0);
-      });
-    });
-
-    it('should have valid patterns', () => {
-      Object.values(FILE_TEMPLATES).forEach(template => {
-        expect(template.pattern).toContain('{content}');
-        expect(template.examples.length).toBeGreaterThan(2);
-      });
-    });
-  });
-});