@amirdaraee/namewise 0.3.0

package/tests/unit/parsers/pdf-parser.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PDFParser } from '../../../src/parsers/pdf-parser.js';
+import path from 'path';
+
+describe('PDFParser', () => {
+  let parser: PDFParser;
+  const testDataDir = path.join(process.cwd(), 'tests/data');
+
+  beforeEach(() => {
+    parser = new PDFParser();
+  });
+
+  describe('supports()', () => {
+    it('should support .pdf files', () => {
+      expect(parser.supports('test.pdf')).toBe(true);
+    });
+
+    it('should not support other file types', () => {
+      expect(parser.supports('test.txt')).toBe(false);
+      expect(parser.supports('test.docx')).toBe(false);
+      expect(parser.supports('test.xlsx')).toBe(false);
+      expect(parser.supports('test.md')).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      expect(parser.supports('test.PDF')).toBe(true);
+      expect(parser.supports('test.Pdf')).toBe(true);
+    });
+  });
+
+  describe('parse()', () => {
+    it('should parse PDF file content correctly', async () => {
+      const filePath = path.join(testDataDir, 'sample-pdf.pdf');
+      const result = await parser.parse(filePath);
+
+      expect(result.content.length).toBeGreaterThan(0);
+      expect(typeof result.content).toBe('string');
+      expect(result.metadata).toBeDefined();
+      // Check for some expected content from the test PDF
+      expect(result.content.toLowerCase()).toMatch(/trace|type|specialization|dynamic|languages/);
+    });
+
+    it('should throw error for non-existent files', async () => {
+      const filePath = path.join(testDataDir, 'non-existent.pdf');
+      
+      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse PDF file');
+    });
+
+    it('should throw error for invalid PDF files', async () => {
+      const filePath = path.join(testDataDir, 'sample-text.txt'); // Not a PDF
+      
+      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse PDF file');
+    });
+
+    it('should trim whitespace from extracted content', async () => {
+      const filePath = path.join(testDataDir, 'sample-pdf.pdf');
+      const result = await parser.parse(filePath);
+
+      expect(result.content).not.toMatch(/^\s/);
+      expect(result.content).not.toMatch(/\s$/);
+    });
+  });
+});

package/tests/unit/parsers/text-parser.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TextParser } from '../../../src/parsers/text-parser.js';
+import path from 'path';
+
+describe('TextParser', () => {
+  let parser: TextParser;
+  const testDataDir = path.join(process.cwd(), 'tests/data');
+
+  beforeEach(() => {
+    parser = new TextParser();
+  });
+
+  describe('supports()', () => {
+    it('should support .txt files', () => {
+      expect(parser.supports('test.txt')).toBe(true);
+    });
+
+    it('should support .md files', () => {
+      expect(parser.supports('test.md')).toBe(true);
+    });
+
+    it('should support .rtf files', () => {
+      expect(parser.supports('test.rtf')).toBe(true);
+    });
+
+    it('should not support other file types', () => {
+      expect(parser.supports('test.pdf')).toBe(false);
+      expect(parser.supports('test.docx')).toBe(false);
+      expect(parser.supports('test.xlsx')).toBe(false);
+      expect(parser.supports('test.png')).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      expect(parser.supports('test.TXT')).toBe(true);
+      expect(parser.supports('test.MD')).toBe(true);
+      expect(parser.supports('test.RTF')).toBe(true);
+    });
+  });
+
+  describe('parse()', () => {
+    it('should parse text file content correctly', async () => {
+      const filePath = path.join(testDataDir, 'sample-text.txt');
+      const result = await parser.parse(filePath);
+
+      expect(result.content).toContain('Project Requirements Document');
+      expect(result.content).toContain('customer management system');
+      expect(result.content).toContain('React.js');
+      expect(result.content.length).toBeGreaterThan(0);
+      expect(result.metadata).toBeDefined();
+    });
+
+    it('should parse markdown file content correctly', async () => {
+      const filePath = path.join(testDataDir, 'sample-markdown.md');
+      const result = await parser.parse(filePath);
+
+      expect(result.content).toContain('Meeting Notes');
+      expect(result.content).toContain('Action Items');
+      expect(result.content).toContain('John, Sarah, Mike');
+      expect(result.content.length).toBeGreaterThan(0);
+      expect(result.metadata).toBeDefined();
+    });
+
+    it('should handle empty files', async () => {
+      const filePath = path.join(testDataDir, 'empty-file.txt');
+      const result = await parser.parse(filePath);
+
+      expect(result.content).toBe('');
+      expect(result.metadata).toBeDefined();
+    });
+
+    it('should throw error for non-existent files', async () => {
+      const filePath = path.join(testDataDir, 'non-existent.txt');
+      
+      await expect(parser.parse(filePath)).rejects.toThrow('Failed to parse text file');
+    });
+
+    it('should trim whitespace from content', async () => {
+      const filePath = path.join(testDataDir, 'sample-text.txt');
+      const result = await parser.parse(filePath);
+
+      expect(result.content).not.toMatch(/^\s/);
+      expect(result.content).not.toMatch(/\s$/);
+    });
+  });
+});

package/tests/unit/services/ai-factory.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { AIServiceFactory } from '../../../src/services/ai-factory.js';
+
+describe('AIServiceFactory', () => {
+  describe('create()', () => {
+    it('should create ClaudeService for claude provider', () => {
+      const service = AIServiceFactory.create('claude', 'test-api-key');
+      
+      expect(service).toBeDefined();
+      expect(service.name).toBe('Claude');
+      expect(typeof service.generateFileName).toBe('function');
+    });
+
+    it('should create OpenAIService for openai provider', () => {
+      const service = AIServiceFactory.create('openai', 'test-api-key');
+      
+      expect(service).toBeDefined();
+      expect(service.name).toBe('OpenAI');
+      expect(typeof service.generateFileName).toBe('function');
+    });
+
+    it('should throw error for unsupported provider', () => {
+      expect(() => {
+        AIServiceFactory.create('unsupported' as any, 'test-api-key');
+      }).toThrow('Unsupported AI provider: unsupported');
+    });
+
+    it('should pass API key to created services', () => {
+      const claudeService = AIServiceFactory.create('claude', 'claude-key');
+      const openaiService = AIServiceFactory.create('openai', 'openai-key');
+      
+      // Services should be created without throwing errors
+      expect(claudeService).toBeDefined();
+      expect(openaiService).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClaudeService } from '../../../src/services/claude-service.js';
+
+// Mock the Anthropic SDK
+vi.mock('@anthropic-ai/sdk', () => {
+  const MockAnthropic = vi.fn().mockImplementation(() => ({
+    messages: {
+      create: vi.fn()
+    }
+  }));
+  return {
+    default: MockAnthropic
+  };
+});
+
+describe('ClaudeService', () => {
+  let service: ClaudeService;
+  let mockClient: any;
+
+  beforeEach(() => {
+    service = new ClaudeService('test-api-key');
+    mockClient = (service as any).client;
+  });
+
+  describe('Basic Properties', () => {
+    it('should have correct name', () => {
+      expect(service.name).toBe('Claude');
+    });
+
+    it('should initialize with API key', () => {
+      expect(service).toBeDefined();
+    });
+  });
+
+  describe('generateFileName() with different naming conventions', () => {
+    const sampleContent = 'This is a project requirements document for Q4 2024 planning meeting.';
+    const originalName = 'document1.pdf';
+
+    beforeEach(() => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: 'project requirements document q4 2024' }]
+      });
+    });
+
+    it('should generate filename with kebab-case convention (default)', async () => {
+      const result = await service.generateFileName(sampleContent, originalName);
+      
+      expect(mockClient.messages.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'claude-3-haiku-20240307',
+          messages: [expect.objectContaining({
+            role: 'user',
+            content: expect.stringContaining('Use lowercase with hyphens between words')
+          })]
+        })
+      );
+      
+      expect(result).toBe('project-requirements-document-q4-2024');
+    });
+
+    it('should generate filename with snake_case convention', async () => {
+      const result = await service.generateFileName(sampleContent, originalName, 'snake_case');
+      
+      expect(mockClient.messages.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: [expect.objectContaining({
+            content: expect.stringContaining('Use lowercase with underscores between words')
+          })]
+        })
+      );
+      
+      expect(result).toBe('project_requirements_document_q4_2024');
+    });
+
+    it('should generate filename with camelCase convention', async () => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: 'project requirements document q4 2024' }]
+      });
+
+      const result = await service.generateFileName(sampleContent, originalName, 'camelCase');
+      
+      expect(mockClient.messages.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: [expect.objectContaining({
+            content: expect.stringContaining('Use camelCase format starting with lowercase')
+          })]
+        })
+      );
+      
+      expect(result).toBe('projectRequirementsDocumentQ42024');
+    });
+
+    it('should generate filename with PascalCase convention', async () => {
+      const result = await service.generateFileName(sampleContent, originalName, 'PascalCase');
+      
+      expect(mockClient.messages.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: [expect.objectContaining({
+            content: expect.stringContaining('Use PascalCase format starting with uppercase')
+          })]
+        })
+      );
+      
+      expect(result).toBe('ProjectRequirementsDocumentQ42024');
+    });
+
+    it('should include original filename and content in prompt', async () => {
+      await service.generateFileName(sampleContent, originalName, 'kebab-case');
+      
+      const call = mockClient.messages.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 truncate long content to 2000 characters', async () => {
+      const longContent = 'a'.repeat(3000);
+      await service.generateFileName(longContent, originalName);
+      
+      const call = mockClient.messages.create.mock.calls[0][0];
+      const contentInPrompt = call.messages[0].content;
+      // Should only contain first 2000 characters
+      expect(contentInPrompt).toContain('a'.repeat(2000));
+      expect(contentInPrompt).not.toContain('a'.repeat(2001));
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle API errors gracefully', async () => {
+      mockClient.messages.create.mockRejectedValue(new Error('API Error'));
+      
+      await expect(service.generateFileName('content', 'file.txt')).rejects.toThrow(
+        'Failed to generate filename with Claude: API Error'
+      );
+    });
+
+    it('should handle non-text response content', async () => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'image', text: null }]
+      });
+      
+      const result = await service.generateFileName('content', 'file.txt');
+      expect(result).toBe('untitled-document');
+    });
+
+    it('should handle empty response', async () => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: '   ' }]
+      });
+      
+      const result = await service.generateFileName('content', 'file.txt');
+      expect(result).toBe('untitled-document');
+    });
+  });
+
+  describe('Filename Sanitization', () => {
+    beforeEach(() => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: 'Test File@#$ Name.pdf' }]
+      });
+    });
+
+    it('should remove file extensions from AI suggestions', async () => {
+      const result = await service.generateFileName('content', 'original.txt', 'kebab-case');
+      expect(result).toBe('test-file-name');
+    });
+
+    it('should handle very long filenames', async () => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: 'a'.repeat(150) }]
+      });
+      
+      const result = await service.generateFileName('content', 'file.txt', 'kebab-case');
+      expect(result.length).toBeLessThanOrEqual(100);
+    });
+
+    it('should preserve naming convention when truncating', async () => {
+      mockClient.messages.create.mockResolvedValue({
+        content: [{ type: 'text', text: 'very long filename that should be truncated properly' }]
+      });
+      
+      const kebabResult = await service.generateFileName('content', 'file.txt', 'kebab-case');
+      expect(kebabResult).not.toMatch(/-$/); // Should not end with hyphen
+      
+      const snakeResult = await service.generateFileName('content', 'file.txt', 'snake_case');
+      expect(snakeResult).not.toMatch(/_$/); // Should not end with underscore
+    });
+  });
+});

package/tests/unit/services/file-renamer.test.ts

@@ -0,0 +1,299 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { FileRenamer } from '../../../src/services/file-renamer.js';
+import { DocumentParserFactory } from '../../../src/parsers/factory.js';
+import { MockAIService } from '../../mocks/mock-ai-service.js';
+import { Config, FileInfo } from '../../../src/types/index.js';
+
+// Mock fs.rename to avoid actual file operations
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    promises: {
+      ...actual.promises,
+      rename: vi.fn(),
+      access: vi.fn()
+    }
+  };
+});
+
+describe('FileRenamer', () => {
+  let fileRenamer: FileRenamer;
+  let mockAIService: MockAIService;
+  let parserFactory: DocumentParserFactory;
+  let config: Config;
+  const testDataDir = path.join(process.cwd(), 'tests/data');
+
+  beforeEach(() => {
+    mockAIService = new MockAIService();
+    parserFactory = new DocumentParserFactory();
+    config = {
+      aiProvider: 'claude',
+      apiKey: 'test-key',
+      maxFileSize: 10 * 1024 * 1024, // 10MB
+      supportedExtensions: ['.txt', '.pdf', '.docx', '.xlsx'],
+      dryRun: false,
+      namingConvention: 'kebab-case',
+      templateOptions: {
+        category: 'general',
+        personalName: undefined,
+        dateFormat: 'none'
+      }
+    };
+
+    fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+
+    // Reset mocks
+    vi.clearAllMocks();
+    mockAIService.resetCallCount();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('renameFiles()', () => {
+    it('should successfully rename files', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      // Mock fs.access to simulate that new file doesn't exist
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(results[0].originalPath).toBe(testFiles[0].path);
+      expect(results[0].newPath).toContain('project-requirements-document.txt');
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).toHaveBeenCalledOnce();
+    });
+
+    it('should handle dry run mode', async () => {
+      config.dryRun = true;
+      fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      // Mock fs.access to simulate that new file doesn't exist
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled(); // Should not rename in dry run
+    });
+
+    it('should handle file size limits', async () => {
+      config.maxFileSize = 100; // Very small limit
+      fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000 // Exceeds limit
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('File size');
+      expect(results[0].error).toContain('exceeds maximum');
+      expect(mockAIService.getCallCount()).toBe(0); // Should not call AI
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should handle unsupported file types', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'unsupported.xyz'),
+          name: 'unsupported.xyz',
+          extension: '.xyz',
+          size: 1000
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('No parser available');
+      expect(mockAIService.getCallCount()).toBe(0);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should handle AI service failures', async () => {
+      mockAIService.setShouldFail(true);
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('Mock AI service failed');
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should handle file conflicts', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      // Mock fs.access to simulate that new file already exists
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('Target filename already exists');
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should handle multiple files', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        },
+        {
+          path: path.join(testDataDir, 'sample-markdown.md'),
+          name: 'sample-markdown.md',
+          extension: '.md',
+          size: 500
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.success)).toBe(true);
+      expect(mockAIService.getCallCount()).toBe(2);
+      expect(fs.rename).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle empty file content', async () => {
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'empty-file.txt'),
+          name: 'empty-file.txt',
+          extension: '.txt',
+          size: 0
+        }
+      ];
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('No content could be extracted');
+      expect(mockAIService.getCallCount()).toBe(0);
+      expect(fs.rename).not.toHaveBeenCalled();
+    });
+
+    it('should not rename if filename would be the same', async () => {
+      // Set up mock to return a name that would result in the same filename
+      mockAIService.setMockResponse('default', 'sample-text');
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(results[0].originalPath).toBe(results[0].newPath); // Same path
+      expect(mockAIService.getCallCount()).toBe(1);
+      expect(fs.rename).not.toHaveBeenCalled(); // No rename needed
+    });
+
+    it('should pass naming convention to AI service', async () => {
+      config.namingConvention = 'snake_case';
+      fileRenamer = new FileRenamer(parserFactory, mockAIService, config);
+
+      // Spy on the generateFileName method
+      const generateFileNameSpy = vi.spyOn(mockAIService, 'generateFileName');
+
+      const testFiles: FileInfo[] = [
+        {
+          path: path.join(testDataDir, 'sample-text.txt'),
+          name: 'sample-text.txt',
+          extension: '.txt',
+          size: 1000
+        }
+      ];
+
+      // Mock fs.access to simulate that new file doesn't exist
+      vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' });
+
+      const results = await fileRenamer.renameFiles(testFiles);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      
+      // Verify AI service was called with the naming convention, category, and file info
+      expect(generateFileNameSpy).toHaveBeenCalledWith(
+        expect.any(String),
+        'sample-text.txt',
+        'snake_case',
+        'general', // Uses general template since that's the default (no auto-categorization)
+        expect.objectContaining({
+          name: 'sample-text.txt',
+          extension: '.txt',
+          documentMetadata: expect.any(Object)
+        })
+      );
+    });
+  });
+});