@amirdaraee/namewise 0.3.0

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

@@ -0,0 +1,196 @@
+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/file-templates.test.ts

@@ -0,0 +1,199 @@
+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);
+      });
+    });
+  });
+});

package/tests/unit/utils/naming-conventions.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { applyNamingConvention, getNamingInstructions, NamingConvention } from '../../../src/utils/naming-conventions.js';
+
+describe('Naming Conventions', () => {
+  describe('applyNamingConvention()', () => {
+    const testText = 'Project Requirements Document 2024';
+
+    it('should apply kebab-case convention', () => {
+      const result = applyNamingConvention(testText, 'kebab-case');
+      expect(result).toBe('project-requirements-document-2024');
+    });
+
+    it('should apply snake_case convention', () => {
+      const result = applyNamingConvention(testText, 'snake_case');
+      expect(result).toBe('project_requirements_document_2024');
+    });
+
+    it('should apply camelCase convention', () => {
+      const result = applyNamingConvention(testText, 'camelCase');
+      expect(result).toBe('projectRequirementsDocument2024');
+    });
+
+    it('should apply PascalCase convention', () => {
+      const result = applyNamingConvention(testText, 'PascalCase');
+      expect(result).toBe('ProjectRequirementsDocument2024');
+    });
+
+    it('should apply lowercase convention', () => {
+      const result = applyNamingConvention(testText, 'lowercase');
+      expect(result).toBe('projectrequirementsdocument2024');
+    });
+
+    it('should apply UPPERCASE convention', () => {
+      const result = applyNamingConvention(testText, 'UPPERCASE');
+      expect(result).toBe('PROJECTREQUIREMENTSDOCUMENT2024');
+    });
+
+    it('should handle text with special characters', () => {
+      const textWithSpecialChars = 'User@Guide & Manual (v2.1)';
+      
+      expect(applyNamingConvention(textWithSpecialChars, 'kebab-case')).toBe('userguide-manual-v21');
+      expect(applyNamingConvention(textWithSpecialChars, 'snake_case')).toBe('userguide_manual_v21');
+      expect(applyNamingConvention(textWithSpecialChars, 'camelCase')).toBe('userguideManualV21');
+      expect(applyNamingConvention(textWithSpecialChars, 'PascalCase')).toBe('UserguideManualV21');
+    });
+
+    it('should handle text with existing hyphens and underscores', () => {
+      const textWithSeparators = 'my-file_name document';
+      
+      expect(applyNamingConvention(textWithSeparators, 'kebab-case')).toBe('my-file-name-document');
+      expect(applyNamingConvention(textWithSeparators, 'snake_case')).toBe('my_file_name_document');
+      expect(applyNamingConvention(textWithSeparators, 'camelCase')).toBe('myFileNameDocument');
+    });
+
+    it('should handle empty and whitespace-only strings', () => {
+      expect(applyNamingConvention('', 'kebab-case')).toBe('');
+      expect(applyNamingConvention('   ', 'kebab-case')).toBe('');
+    });
+
+    it('should normalize multiple spaces', () => {
+      const textWithSpaces = 'Meeting   Notes    From   Today';
+      expect(applyNamingConvention(textWithSpaces, 'kebab-case')).toBe('meeting-notes-from-today');
+    });
+
+    it('should default to kebab-case for unknown convention', () => {
+      const result = applyNamingConvention(testText, 'unknown' as NamingConvention);
+      expect(result).toBe('project-requirements-document-2024');
+    });
+  });
+
+  describe('getNamingInstructions()', () => {
+    it('should return correct instructions for each convention', () => {
+      expect(getNamingInstructions('kebab-case')).toContain('lowercase with hyphens');
+      expect(getNamingInstructions('snake_case')).toContain('lowercase with underscores');
+      expect(getNamingInstructions('camelCase')).toContain('camelCase format starting with lowercase');
+      expect(getNamingInstructions('PascalCase')).toContain('PascalCase format starting with uppercase');
+      expect(getNamingInstructions('lowercase')).toContain('single lowercase word');
+      expect(getNamingInstructions('UPPERCASE')).toContain('single uppercase word');
+    });
+
+    it('should include examples in instructions', () => {
+      expect(getNamingInstructions('kebab-case')).toContain('meeting-notes-2024');
+      expect(getNamingInstructions('snake_case')).toContain('meeting_notes_2024');
+      expect(getNamingInstructions('camelCase')).toContain('meetingNotes2024');
+      expect(getNamingInstructions('PascalCase')).toContain('MeetingNotes2024');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.{ts,js}'],
+    exclude: ['node_modules', 'dist'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/types/**', 'src/**/*.d.ts'],
+      reporter: ['text', 'json', 'html'],
+      thresholds: {
+        global: {
+          branches: 80,
+          functions: 80,
+          lines: 80,
+          statements: 80
+        }
+      }
+    }
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, 'src')
+    }
+  }
+});